Jonathan Kelley

Jonathan Kelley created Dioxus, a Rust framework for building web, desktop, and mobile applications, and founded Dioxus Labs. His work combines native performance with familiar interface tools, while tackling the rendering, packaging, and development machinery needed to make a cross-platform framework practical. The Dioxus team’s September 2026 move to Cognition extended that work into the environments where coding agents build and test software.

From undergraduate project to Dioxus Labs

Kelley’s early career crossed scientific research and systems engineering. He interned at NASA, researched plasma physics, and worked at Cloudflare on the 1.1.1.1 DNS service and WARP. He studied at Franklin W. Olin College of Engineering and began Dioxus during his undergraduate years. In his account of the project’s origins, he describes spending his final undergraduate summer exploring a cross-platform application framework rather than taking an internship or pursuing AI research.

The idea was to write application logic in Rust, describe interfaces with HTML and CSS, and share components across platforms. Rust supplied native performance, a strong type system, and cross-compilation; React-like reactivity made the interface model familiar to web developers. Delivering that combination required more than a component library. The team had to build reactivity, font rendering, hot reloading, and application bundling into a usable development stack.

By 2023, Kelley had left Cloudflare to work on Dioxus full time. Support from Futurewei, Satellite.im, and GitHub’s Accelerator program also enabled contributors to work on the project professionally. Dioxus Labs entered Y Combinator’s Summer 2023 batch, developing the undergraduate project into a company focused on helping small teams ship cross-platform applications.

Hot reloading and native rendering

Dioxus integrates reactive state, server functions, styling, bundling, and development tools so developers can spend more time on application behavior and less on assembling platform-specific toolchains. Its expansion produced two substantial projects that address different parts of the development loop: updating a running application and rendering its interface.

• Subsecond: live code updates: Subsecond, introduced with Dioxus 0.7 in September 2025, lets developers change Rust code without restarting an application and losing its state. It uses incremental linking and binary patching to replace changed code in the running process. Frameworks provide explicit integration points where updates can be applied safely. Those points matter because replacing instructions alone does not resolve every problem: an application may be waiting for input, or a change may alter the structure of data already in memory. The framework must still handle affected state safely. Subsecond’s integration extends beyond Dioxus to other Rust applications.
• Blitz: native HTML/CSS rendering: Blitz, developed by Kelley’s team, is a modular HTML/CSS rendering engine that powers Dioxus Native. It combines Stylo for CSS resolution, Taffy for layout, and Parley for text with rendering and system-integration components. The design separates interface rendering from the other facilities packaged into a browser. A native application can use Rust libraries for networking, storage, and device access while retaining familiar HTML and CSS for its interface. Blitz remains a beta implementation with rendering bugs and missing features; its contribution is an alternative architecture for native interfaces, with explicit limits to its compatibility.

Building environments for coding agents

As coding models became more capable at Rust, the team also built SkyVM, a cloud coding harness supporting multiple operating systems. Virtual-machine snapshots, forks, and rollbacks allow development environments to be resumed, branched, and restored. This expanded the team’s work from application frameworks into the infrastructure agents need to sustain development and test platform-specific behavior.

Kelley’s approach to agents grew out of a difficult adoption process. The Dioxus team initially doubted that AI-generated code could meet its standards. When models improved, enthusiasm produced thousands of lines of proposed features, fixes, and integrations, but many changes remained in draft because they failed review. In Building ambitious software, Kelley uses that experience to explain why faster implementation increases the importance of architecture and clear intent.

Agent contributions and engineering responsibilities

• Platform integration: He finds agents especially useful for platform integration: work requiring knowledge scattered across operating-system APIs, build systems, and documentation. For Dioxus’s Kotlin and Swift plugins, he reports that implementation came together quickly, while test cases and real-device validation occupied much of the following two weeks. In Blitz, agents helped investigate CSS and layout problems by drawing on specifications and browser behavior. Their patience and breadth of knowledge made it easier for the team to investigate difficult integrations thoroughly.
• Release maintenance: Agents also helped with release checklists, backporting fixes, checking documentation, and other repetitive maintenance. These tasks matter unusually much for a framework: developers build businesses on its APIs, read its examples, and depend on stable releases. A code change that leaves a comment inaccurate or breaks an editor extension can undermine the product even when its central functionality still works. Kelley reports that agent assistance supported a more frequent patch-release cadence.
• Meaningful tests: His confidence is more selective around meaningful tests. An agent can test that a constructor returns an object while overlooking the behavior users depend on. Foundational software also poses practical testing problems: checking that an editor extension really installs and works may require opening the editor and exercising it. The team therefore continues to identify important conditions and design testing APIs itself. Kelley values agents as partners for exploring edge cases and building fuzzing harnesses, which expose software to large numbers of inputs, including malformed and adversarial cases.
• Architecture and code review: For Kelley, software architecture and code review remain central responsibilities. A generated fix can solve an immediate problem while making later features harder to implement. His team continues to read pull requests line by line, using AI review to help spot bugs while retaining human judgment about what should ship. Communicating intent matters because contributors and models may optimize for the requested change without considering how the whole framework should evolve.

Continuing the work at Cognition

The Cognition announcements connect these concerns to Devin’s virtual machines, computer use, and testing capabilities, alongside continued support for the team’s open-source projects. Kelley’s announcement credits Nico Burns as Blitz’s lead engineer and identifies his full-time commitment to continued Dioxus development. Across this work, Kelley’s position is consistent: cheaper code generation makes it more valuable to design systems that can absorb change, choose tests that expose real failures, and understand the code being released.