Releasing ALL tools and frameworks we build as open source.

We're hoping that together in the open-source, local-first community, we can build something better than any closed-source alternative. The code is open-source because I believe that fundamental tools shouldn't require trusting a black box. Companies pivot, get acquired, or shut down. But open source is forever.

Independent software developers in China, like us, have 10 times more life pressure than Marak, the author of faker.js. Since ydotool has the opportunity to benefit large IT companies who won't pay a penny to us, we've changed the license to AGPLv3. These large IT companies are the main cause of life pressure here, such as the "996" working hours.

This is why I am very careful about how I make "useful" software and release it to the world without any solid way for me to get paid for my efforts. I simply do not want to be in a situation where my software that I develop as a passion project on the side is holding people's companies together. That's why I make software how and where I do. Like, no offense, but I really do not want to go unpaid for my efforts. The existing leech culture of "Open Source" being a pool of free labor makes it hard for me to want to have my side projects be actually useful like that unless you pay me.

If you want me to make you useful software, pay me. If you use software made by others in their spare time and find it useful, pay them. This should not be a controversial opinion. This should not be a new thing. This should already be the state of the world and it is amazingly horrible for us to have the people that make the things that make our software work at all starve and beg for donations.

There is this culture of taking from open source without giving anything back. It is like the problems of the people who make the dependencies are irrelevant.

GitHub stars famously cannot be used to pay rent.

Strict No LLM / No AI PolicyNo LLM-generated content, whether it be code or prose.No paraphrasing LLM-generated content.No LLMs for editing, including fixing spelling or grammatical errors.No LLMs for translation. English is encouraged, but not required. You are welcome to post in your native language and rely on others to have their own translation tools of choice to interpret your words.No LLMs for brainstorming and then sharing the results of that brainstorming, even if you create the prose. If you use a chatbot to give you advice on a comment on the issue tracker, that comment is unwelcome.No LLMs for finding bugs.

But you can only do this on Linux. With Windows and macOS, the core elements of the operating system are owned by the companies that make them. While it's often possible to hack certain aspects, it's far from truly having the malleable computer that Linux allows.

My last pillar of expertise is now reduced to a 'taste' and will probably won't last long.

Why testing is much harder than "computer use" Screenshots, video verification, and the "I know it works" merge moment

Cursor is no longer primarily about writing code . It is about helping developers build the factory that creates their software . This factory is made up of fleets of agents that they interact with as teammates : providing initial direction, equipping them with the tools to work independently, and reviewing their work.

Claude Code with Opus 4.8 can now carry out codebase-scale migrations across hundreds of thousands of lines of code from kickoff to merge

This dynamic UI management is the future of software value : the harness to control the interface/ensure it's correct & the knowledge management to rationalize all the AI products over time

Software systems need to decide which of these to keep over time & which are disposable ; those newer semi-permanent artifacts will become the new heads

The critical insight in the Oz analogy is that roughly half of any real workflow that is non-agentic carries no lab advantage. They are no better than you are at writing the deterministic software underneath the model layer.

The model is fungible underneath; the system of work is not. The next generation of enterprise software is going to be built off the road.

The result is a new competitive dynamic in software.

However, production-grade software requires strict adherence to structural constraints, such as architectural patterns, databases, and object-relational mappings.

AI writes features, not architecture. The longer you let it drive without constraints, the worse the wreckage gets.

The velocity makes you think you're winning right up until the moment everything collapses simultaneously.

If you can go from producing 200 lines of code a day to 2,000 lines of code a day, what else breaks? The entire software development lifecycle was, it turns out, designed around the idea that it takes a day to produce a few hundred lines of code.

So I realized what I value more than the quality of the tests and documentation is that I want somebody to have _used_ the thing.

So I realized what I value more than the quality of the tests and documentation is that I want somebody to have _used_ the thing. If you've got a vibe coded thing which you have used every day for the past two weeks, that's much more valuable to me than something that you've just spat out and hardly even exercised.

software engineering tasks which may take humans weeks seem to be within reach for AI systems.

An engineer at Cloudflare used Claude with OpenCode to release vinext, a reimplementation of Next.js on Vite, for only ~$1,100 in API costs.

Most passing SWE-Bench solutions are not accepted by maintainers.

Still, the psychologist argues, “there’s no longer an excuse for releasing models that reinforce user delusions so readily.” “When one lab’s models can largely maintain safety across extended conversations, while others are willing to validate extremely harmful outcomes — up to and including a user’s suicidal ideation — it suggests this isn’t a flaw in the technology,” said Nicholls, “but a result of specific engineering and alignment choices.”

The one real underlying asset, Workday's trillion-transaction dataset, is thinner than it sounds; what actually matters at runtime is how data connects to workflows, permissions, and integrations, and every layer of that stack is now a liability.

When customers renew at close to 100% every year, it's usually read as a sign the product is delightful. In Workday's case, it's a sign of something else: leaving is close to impossible.

Our early versions of agentic work was only asking Codex to implement the task. That approach proved too limiting. Codex is perfectly capable of creating multiple PRs as well as reading review feedback and addressing it.

Six months ago, while working on an internal productivity tool, our team made a controversial (at the time) decision: we'd build our repo with no human-written code. Every line in our project repository had to be generated by Codex.

The fix is not smarter prompts. It is software built to meet agents halfway.

The fix is not smarter prompts. It is software built to meet agents halfway.

In other words, COSMIC behaves more like a collection of coordinated tools than a single monolithic environment. This makes the system easier to evolve over time. Components can be updated or replaced without rewriting the entire desktop. It’s a surprisingly modern design philosophy for a Linux desktop environment, and it’s one of the reasons many developers are watching COSMIC closely.

By customizing and co-designing silicon with hardware, networking and software, including model architecture and application requirements, we can deliver dramatically more power efficiency and absolute performance.

We spent days loading the system with hundreds of threads, refining rough edges and polishing corners that developers may never see.

What we've found works best for crafting high-quality software is somewhere in between: using AI, and also engaging directly with code.

Zig distributes its toolchain as a Python package, which is built on the assumption that virtually all computers already have a Python distribution of some kind.

AI writes the code. Tests verify correctness. More code enables more features.

More code enables more features. Companies will always need more software

There were 1 billion commits in 2025. Now, it's 275 million per week, on pace for 14 billion this year if growth remains linear

On the SWE-Pro benchmark, M2.7 scores 56.22%, nearly matching Opus's best level.

M2.7 demonstrates excellent performance in real-world software engineering, including end-to-end project delivery, log analysis for bug hunting, code security, and machine learning tasks.

On the SWE-Pro benchmark, M2.7 scores 56.22%, nearly matching Opus's best level.

Four researchers and software engineers estimated that a skilled human engineer would take 2 to 17 weeks to reimplement gotree, as AI successfully did in this work.

It is not common for real software to be developed the way MirrorCode tasks are structured — against a precise, programmatically checkable specification.

Claude Opus 4.6 autonomously reimplemented a 16,000-line bioinformatics toolkit — a task we believe would take a human engineer weeks.

GLM-5.1 achieves state-of-the-art performance on SWE-Bench Pro and leads GLM-5 by a wide margin on NL2Repo (repo generation) and Terminal-Bench 2.0 (real-world terminal tasks).

Xcode should ship with a built-in MCP that handles auth when an LLM connects to a project. Notion should have `mcp.notion.so/mcp` available natively, instead of forcing me to download `notion-cli` and manage auth state manually.

When a remote MCP server is updated with new tools or resources, every client instantly gets the latest version. No need to push updates, upgrade packages, or reinstall binaries.

Being open source is increasingly like giving attackers the blueprints to the vault. When the structure is fully visible, it becomes much easier to identify weaknesses and exploit them.

There was a time that whenever you looked at search results on Google, you could click the "Cached" button to view an archived version of the page. Unfortunately, Google has decided to remove the feature. The company's stated reason is that the feature was created to allow users a way to see the content at a time when sites would go offline frequently, and that the basic functionality of the internet has improved to the extent that it's no longer necessary. Whatever the reason, it means yet another useful feature has found itself in Google's graveyard.While Google may profess that feature isn't relevant any longer, that's not the case. Posts are deleted all the time, link rot is very real, and entire sites are regularly purged from existence Any time you want to access a post that has been removed due to corporate or political censorship, you now have one less tool to see what was published. Google's cache was also among the most reliable ways to access pages that would take a long time to load or keep going down frequently, something that still happens with smaller blogs or with sites run by the government in plenty of regions in the world.Any time a web page failed to work as expected, you could easily access Google's cache directly from the search results, but that button has now been removed—if not the functionality itself. Because at the time of this writing, there remain a few easy workarounds that allow you access Google's cached webpages.

Obsidian is the IDE; the LLM is the programmer; the wiki is the codebase.

You don’t realise how slow/laggy VSCode and the all of the forks are until

Implicit state is the Enemy

This class of bug is insidious because it evades every layer of defense. It will not be caught in development testing — who runs a test for 50 days? It will not be flagged in code review — the logic looks perfectly reasonable.

Looking at the code and having opinions on architecture is seen as just as 'bad' as calling a compiled C module from an interpreted language was seen back in the day... it's not bad, it's actually quite practical, but it violates some strange 'purity'.

Bad software is a decision you make. You need to own it. You should do better.

Looking under the hood is cheating. You're only supposed to have vague conversations with the machine about what it's doing.

This means 2.7x more tokens from the same GB300 NVL72-based infrastructure and power footprint, reducing the cost to manufacture each token by more than 60%.

TAM posits that the intention to adopt a particular technology is driven by two kinds of perceptions: (1) how easy it is to use a system and (2) how useful it will be to use it [180]. Furthermore, the perceived ease of use affects the perceived usefulness: If technology is hard to use, it is less useful.

it is perfectly possible to have a program which is structured, modular, readable, flexible, self-documenting, maintainable, which performs its specified function, and which is a source of constant frustration and irritation to its users.

The theory of task–technology fit (TTF) can illuminate what users consider useful and how this affects their decision to adopt a particular technology. TTF refers to the ability of technology to support a task [197]. The capabilities of the technology should match the demands of the task and the skills of the individual; in this case, the fit is perfect.

Users actively repurpose tools to make them more personally usable and relevant. Design should support such repurposing. For example, Renom et al. [696] conducted a study on text editing using a novel user interface. They found that exploration and technical reasoning facilitate creative tool use.

One prominent definition of accessibility is given by ISO 9241-171, which defines it as 'the usability of a product, service, environment or facility by people with the widest range of capabilities.'

The second dimension, social acceptability, concerns whether interactions map well to the social norms and roles in the settings where they occur.

Acceptability has two main dimensions [591]. The first dimension, practical acceptability, includes costs, the reliability of the interactive system, and its compatibility with other systems. The perceptions of utility and usability may also influence the judgment of practical acceptability.

usability is multidimensional. This means that in most settings, a valid characterization of usability will need to employ several dimensions and measures.

usability is measurable, that is, it is possible to quantify usability based on users' behaviors or opinions.

usability is relational; it arises as an interplay between people, tasks (problems), and interactive systems (tools)

ISO 9241-11 definition... defines usability as the 'extent to which a system, product or service can be used by specified users to achieve specified goals with effectiveness, efficiency and satisfaction in a specified context of use.'

One shorthand way of expressing this is that utility is 'whether the functionality of a system in principle can do what is needed' [591, p. 25]. In practice, whether people can do anything concerns—among other things—usability.

The utility of an interactive system concerns its match with the tasks of users. If the match is good, the tool has high utility; if the tasks that users want to do are not supported by the tool, the tool has low utility.

Usability concerns how easily computer-based tools may be operated by users trying to accomplish a task. Usability differs from utility. Usability concerns whether users can use the product in a way that makes it possible to realize its utility; utility is about whether the goal is important to the user. Ideally, the user can use the tool without unnecessary effort so that the use is direct, transparent, and unnoticeable.

Usability is one of the best predictors of users' willingness to adopt software. For example, the User Burden Scale is a questionnaire for measuring the felt burden in software use [806]. It consists of six subscales: difficulty of use, physical burden, time and social burden, mental and emotional burden, privacy burden, and financial burden.

The unofficial API authenticates using your actual Sunsama email and password. So my serverless function needs to store my real credentials.

I've skimmed Crafting Interpreters and the Bytecode VM section seems to spend an inexplicable amount of time on not only parsing, but minutia having nothing to do with compilers (e.g. writing a custom dynamic array implementation in C).

We envision a component generator with knobs thatlet a user choose among design decisions, akin to sim-ilar work for code generation from design patterns [1].Such a tool is sufficiently parameterized to generateany combination of implementation trade-offs on thespectrum from fully static to fully dynamic compo-nents. The components that result can thus exhibitjust the right combination of flexibility, maintainabil-ity, and performance, with a minimum of specificationand hackery on the developer’s part.

for me, a software component is a reusable software element, typically some library classes, usually in source form (not binary form), which differs from Clemens Szyperski’s view

code of view wasn't about catching bugs. It was a primary mechanism for knowledge transfer. When your engineers learn architecture by reading senior engineer PRs, seniors maintain context by reviewing everything, and code of view was the learning loop. It was how shared theory was built and maintained across the entire team. But AI bypasses that entire loop. The code shows up, it works, it gets merged, but nobody learned anything. Nobody built context. Nobody can debug at a 3AM without reprompting the AI. And code of view was never about catching bugs. It was always about building shared understanding. AI skipped the most important step.

Feudalismo

most front-end developers have normalised doing daily trust falls with their codebases

Lua is more dynamic than Wren which makes its job harder. Lua also tries very hard to be compatible across a wide range of hardware and compilers. If you have a C89 compiler for it, odds are very good that you can run Lua on it. Wren cares about compatibility, but it requires C99 or C++98 and IEEE double precision floats. That may exclude some edge case hardware, but makes things like NaN tagging, computed gotos, and some other tricks possible.

Languages come in four rough performance buckets, from slowest to fastest

And when you work with a team, you are stuck anyway with the worst possible tool that satisfies the need of the dumbest member of the team. Usually the manager.

Commercial software whose source code you were legally prohibited from reading was “antithetical to the idea of science,” where the very purpose is to open the black box of nature.

This makes questions like “how fast is WebAssembly” a bit hard to answer. You don’t ask how fast algebraic notation is—it’s not a very sensible question. Taken in the context of something like JavaScript, the language is only as fast as the engine running it. JavaScript the language has no speed, but you can benchmark JS engines like V8, SpiderMonkey, and JavaScriptCore. You can benchmark the IO libraries of JS runtimes like Bun, Deno, and Node. What people actually mean is “how useful are the constructs of this language to efficient mappings of modern hardware” and “what is the current landscape of systems taking advantage of these constructs”.

We’re bringing a social experience to Anytype by making spaces more interactive. We start with the concept of one space = one group = one chat. Then we’ll expand to include discussions on objects, enabling forum-like use cases. It will significantly improve collaborative use cases. You’ll chat and discuss your pages and files in the same end-to-end encrypted and local-first way.

Koha Library Software The world's first free and open source library system

Most complex software ships with a few bugs. Obviously, we want to avoid them, but the more complex a feature is, the harder it is to cover all the use-cases. As we get closer to our RC date, do we feel confident that what we're shipping has as few blocking bugs as possible? I would like to say we're close, but the truth is I have no idea. It feels like we'll have to keep trying the features for a bit until we don't run into anything - but we have less than 3 weeks before the RC ships. Here's a few surprising bugs that need to get fixed before I would feel comfortable shipping node12 in stable.

One pattern that I love to use in my SvelteKit projects is returning writable stores from the layout’s load function. This makes it possible to fetch data from the server (for example the user object for the logged in user), and then you make this object available as a writable reactive store throughout the whole application. So when the user updates their username or avatar, you do the PUT request to the server and you get the updated user object back from the server as the response, you can simply update the $user writable store value and every place in your app where you show the user object gets updated immediately.

Another limitation in this implementation is that passing other options in the shebang to vite-node won't work, as I expect exact indexes in order to figure out what are the arguments to forward. It's not perfect but I think it's good enough to unblock people like me as a start. 👍

los documentos como aspectos separados y encerrados de nuestra experiencia de cómputo

los documentos como aspectos separados y encerrados de nuestra experiencia de cómputo

los documentos como aspectos separados y encerrados de nuestra experiencia de cómputo

Many in Silicon Valley believe we're less than a year away from AI that can automate most software engineering work

Vite's job is to get your source modules into a form that can run in the browser as fast as possible. To that end, we recommend separating static analysis checks from Vite's transform pipeline.

Vite uses esbuild to transpile TypeScript into JavaScript which is about 20~30x faster than vanilla tsc, and HMR updates can reflect in the browser in under 50ms.

Above: the time to do a production bundle

However, I also feel that Ruby sometimes seems too focused on being backwards compatible, to a point where it risk hurting the ecosystem. I think this thread is a good example, because it seems like such a small and benign change, yet it's taken several years and lots of back and forth, and in the end the proposed change wasn't even applied(!?).

With its "no downstream hacks" and "upstream first" approach, it acts as a cutting-edge catalyst to push open-source technologies we love forward.

Simply choosing a more efficient programming language speeds up this calculation

but once I got some momentum there, I switched to Krita and never looked back. Looking back I’d just skip Corel and start with Krita

Why is more important than how

Everything is a trade-off

Software architecture choices include specific structural options from possibilities in the design of the software.

The software design model can be compared to an architected plan for a house. High-level plans represent the totality of the house (e.g., a three-dimensional rendering of the house). Lower-level plans provide guidance for constructing each detail (e.g., the plumbing lay). Similarly, the software design model provides a variety of views of the proposed software solution.

including both high-level software architecture and low-level component and algorithm design.

The first one is about using the code artefacts (classes, variables, modules, …) names to convey both domain and architectural meaning.

“[…] an architecturally evident coding style that lets you drop hints to code readers so that they can correctly infer the design.”

Another problem is that now your business logic is obfuscated inside the ORM layer. If you look at the structure of the source code of a typical Rails application, all you see are these nice MVC buckets. They may reveal the domain models of the application, but you can’t see the Use Cases of the system, what it’s actually meant to do.

We are destroying software mistaking it for a purely engineering discipline.