01
One Application Model
Developers should express components, data, state, and behavior in one model, without separately managing HTML, CSS, DOM reconciliation, and multiple frontend frameworks.
Project Runtime
An experimental GPU-native, AI-native application runtime built with Rust.
MinTech product research · Rust · GPU · AI
Make application development about applications again.
An experimental application runtime exploring a simpler, GPU-native, and AI-native foundation for building demanding software.
Research & Early Prototype
An independent product R&D initiative by MinTech.
Software has evolved. Its foundations deserve another look.
Modern application development has accumulated decades of complexity. We are exploring what a purpose-built application platform could look like if designed from first principles today.
Developers building interactive software often need to combine HTML, CSS, JavaScript, frontend frameworks, state management, styling systems, build tools, rendering optimizations, and many additional libraries.
- HTML
- CSS
- JavaScript
- Frontend frameworks
- State management
- Styling systems
- Build tools
- Rendering optimizations
- Additional libraries
Those technologies have enabled tremendous innovation. Their accumulated complexity also creates an opportunity to rethink application development for software that wants a more coherent foundation.
What if applications had their own purpose-built runtime?
The project explores an alternative to the traditional HTML, CSS, JavaScript, and DOM application stack. It is not intended to replace the existing Web, and it is not a path to full browser compatibility.
The focus is a new category of applications designed specifically for this runtime.
Applications, not documents
The Web originally evolved around documents. We are exploring an application-first runtime designed for interactive software.
Traditional web application
- 01Application
- 02Framework
- 03DOM / CSS
- 04Browser engine
- 05GPU
Proposed runtime
- 01Rust application
- 02Semantic components
- 03Runtime
- 04GPU
A conceptual diagram, not a claim that every intermediate cost disappears.
Initial target workloads
- 01Large-scale spreadsheets and data grids
- 02Design and image editing tools
- 03PDF and document applications
- 04Developer tools and IDE-like interfaces
- 05Other data-intensive, graphics-intensive applications
Core principles
Six ideas guiding the research. Each one is a direction to test, not a finished capability.
02
GPU-Native Rendering
Explore a Rust-based rendering pipeline using technologies such as wgpu and native graphics APIs. Performance improvements are hypotheses that must be validated through benchmarks.
03
Semantic-First Components
Components should carry machine-readable structure: what they are, what data they hold, and which actions they expose.
04
AI-Native Interaction
Agents should be able to understand and act on application intent, rather than relying exclusively on DOM inspection, screenshots, and simulated mouse clicks.
05
Sandboxed Execution
Applications downloaded from a domain must execute inside a sandbox. The proposed architecture explores WebAssembly, capability-based permissions, and isolation.
06
Integrated Developer Experience
Strong defaults, fewer concepts, consistent components, integrated tooling, and minimal configuration.
Designed from first principles.
A proposed path from an application URL to the GPU. Networking and an AI semantic interface connect to the runtime as capabilities.
01
Domain / Application URL
02
Manifest + Application Module
03
WebAssembly Sandbox
04
Semantic Component Runtime
05
Layout + Scene Graph
06
GPU Renderer
07
Metal / Vulkan / Direct3D
Proposed architecture — subject to change as research and prototyping progress.
Applications that AI can understand, not just see.
Existing agents frequently rely on accessibility trees, DOM inspection, screenshots, and simulated interactions. We are exploring an application model that exposes structured actions and data capabilities.
The aim is for an agent to work with application intent. That interface is a research direction. It has not been implemented.
Pixel-based interaction
How agents often operate on today’s applications.
- Accessibility trees
- DOM inspection
- Screenshots
- Simulated mouse clicks
Semantic capability-based interaction
A sketch of structured actions a grid could expose.
DataGrid
- filter(column, condition)
- sort(column, direction)
- select(query)
- export(format)
Permissions, authorization, and sensitive data protection are essential parts of this design.
Our first experiment: a high-performance DataGrid.
The first proof of concept will focus on a spreadsheet-style application capable of handling large logical datasets through virtualization and efficient rendering.
There is no public demo and no published benchmark. The work is still ahead of us.
Key experiments
- 01Large datasets and viewport virtualization
- 02Responsive scrolling and cell editing
- 03Memory and rendering efficiency
- 04Native GPU rendering
- 05Structured AI interaction with grid operations
- 06Reproducible comparisons against optimized browser implementations
We will measure results rather than assume performance advantages.
Research roadmap
A working sequence for the research. No dates, and no phase is marked complete.
Phase 01
Current focus
Research & Architecture
Evaluate existing runtimes, security models, rendering approaches, and competing technologies.
Phase 02
Planned
Runtime Prototype
Implement a minimal Rust host, component model, and rendering pipeline.
Phase 03
Planned
DataGrid Benchmark
Build a functional data-intensive demo and benchmark it against browser alternatives.
Phase 04
Planned
Semantic AI Interface
Prototype typed application capabilities and agent interactions.
Phase 05
Planned
Open-Source Evaluation
Publish technical findings and evaluate a public open-source release.
Current Status: Research & Early Prototyping
This project is experimental. Its architecture, performance characteristics, and long-term feasibility are still being validated.
Built by MinTech.
Project Runtime is an independent product research initiative by MinTech, exploring new foundations for high-performance and AI-native application development.