Google Mastercard Intel Airbus Pfizer Inc BMW Infosys Bosch Sky GE Healthcare Raytheon European Patent Office Deloitte Consulting Miele PayPal Motorola Mobility LLC Philips Siemens Fujifilm Corporation

How it works

From an empty folder to a signed app installer

Generate a project, build the app yourself or with your AI coding agent, review the running app, and ship native installers with automatic updates.

One command creates a project with everything AI agent needs.

Describe what you need and let your coding agent write and test it.

Run the app, point at what’s off, and turn your notes into precise tasks for your agent.

Brand, sign, and package the app into native installers, then keep users up to date.

$ npm create mobrowser-app@latest
✔ Project name: App
✔ Add a native module? No
✔ Initialize a Git repository? Yes
✔ Code generation completed successfully
    Generated code location:
        /Users/user/Projects/App/src/main/gen
        /Users/user/Projects/App/src/renderer/gen
? Open it in a coding agent/IDE:
  ChatGPT Desktop (Codex)
❯ Claude Desktop
  Cursor
  No
  • TypeScript, React, Vite, shadcn/ui, C++/Rust module
  • GitHub CI/CD workflows for Windows, macOS, Linux included
  • Docs, API reference, rules, and skills for AI agents included
  • Opens in Claude Code, Codex, Cursor, or VS Code

Examples

Explore apps built with MōBrowser

Real desktop apps, each built from a single TypeScript codebase and packaged for different desktop platforms. Pick an app, see how it looks, download and see it in action, read its source code on GitHub.

Reminders

Keep your tasks in color-coded lists, with subtasks and due dates.

A desktop to-do app inspired by Apple Reminders. Organize tasks in your own lists, nest subtasks, set due dates and priorities, and see what is due in the Today and Scheduled smart lists. It supports search, undo, keyboard shortcuts and menus, light and dark themes, and launch at login.

  • React
  • TypeScript
  • shadcn/ui
  • Tailwind CSS
  • Playwright
Platforms
Download size
166 MB
Browse the source

Cross-platform

One codebase. The same app on every desktop.

Every MōBrowser app ships with its own Chromium engine and Node.js runtime. Your app UI renders with the same engine version and your code runs on the same runtime on Windows, macOS, and Linux, so you can build and test it once.

What’s inside every app

The same layers ship with your app on every platform. You write only the top one.

Your app

  • Frontend TypeScript, React, Vite, shadcn/ui, TailwindCSS
  • Backend Business logic in TypeScript and Node.js
  • Native module Optional, C++ or Rust

MōBrowser

  • Chromium One rendering engine, one version
  • Node.js Runtime and the npm ecosystem
  • Native APIs Windows, menus, tray, dialogs, notifications

Operating System

  • Windows x64
  • macOS Apple Silicon
  • macOS x64
  • Linux x64
  • TypeScript-native

    Write the backend and the UI in TypeScript, in one codebase, and run it natively on Windows, macOS, and Linux.

  • Consistent rendering

    One modern Chromium engine draws your UI everywhere, so layouts, fonts, and CSS behave the same on every OS. No system WebView differences to test around.

  • Node.js runtime

    Use familiar Node.js APIs and the full npm ecosystem, with the same runtime on every platform.

  • C++ or Rust when you need it

    Add a native C++ or Rust module to reach platform APIs or speed up compute-heavy tasks, without leaving the project.

Perfect for

Desktop apps that businesses depend on

MōBrowser is built for teams that ship and maintain desktop software for years, where security, updates, and vendor support matter as much as the UI.

Talk to us about your app
  • Internal business tools

    Dashboards, admin consoles, and back-office apps your teams use every day on Windows, macOS, and Linux.

  • Companion apps for hardware

    Set up, configure, and update mice, keyboards, printers, and lab instruments through a native C++ or Rust module.

  • Commercial desktop products

    Software you sell, signed installers, and automatic updates built in.

  • Desktop clients for web apps

    Bring your SaaS to the desktop with a tray icon, notifications, global shortcuts, and native menus.

  • Apps in regulated industries

    Finance, healthcare, and the public sector, where you need SBOM, dependency transparency, and timely security updates.

  • Developer & productivity tools

    Editors, viewers, and utilities that need fast, consistent UI and deep access to the file system.

Platform integration

Go native when your app needs to

A desktop app has to work closely with the operating system. Add a native module in C++ or Rust to call system APIs, reuse the libraries you already have, and talk to hardware, from the same project and the same TypeScript code.

  • System APIs

    Call operating system APIs that Node.js and the MōBrowser API don’t expose, and link system frameworks such as Cocoa.

  • Existing libraries

    Reuse the C++ and Rust code your team already has instead of rewriting it in TypeScript. Link it with CMake or Cargo.

  • Hardware access

    Work with devices and peripherals at a low level, for companion apps, kiosks, and lab or industrial tools.

  • Native performance

    Move image processing, video encoding, cryptography, and heavy math to native code.

One contract, typed code on both sides

1 Define the interface src/native/proto/greet.proto
message Person {
  string name = 1;
}

service GreetService {
  rpc SayHello (Person) returns (google.protobuf.StringValue);
}
2 Implement it in C++ src/native/main.cc
class GreetServiceImpl : public GreetService {
 public:
  void SayHello(const Person* person,
                Callback<StringValue> done) override {
    StringValue response;
    response.set_value("Hello, " + person->name() + "!");
    std::move(done).Complete(response);
  }
};
3 Call it from TypeScript src/main/index.ts
const response = await native.greet.SayHello({ name: 'John Doe' })
console.log(response.value) // Hello, John Doe!
1 Define the interface src/native/proto/greet.proto
message Person {
  string name = 1;
}

service GreetService {
  rpc SayHello (Person) returns (google.protobuf.StringValue);
}
2 Implement it in Rust src/native/lib.rs
struct Greeter;

impl GreetService for Greeter {
    async fn say_hello(&self, person: Person) -> Result<String, String> {
        Ok(format!("Hello, {}!", person.name))
    }
}
3 Call it from TypeScript src/main/index.ts
const response = await native.greet.SayHello({ name: 'John Doe' })
console.log(response.value) // Hello, John Doe!
  • Type-safe in both directions

    Call native code from TypeScript and TypeScript from native code through generated Protobuf services.

  • One command to add

    Pick C++ or Rust when you create a project, or add a module later with npm run add native.

  • Built for every target

    The module compiles with your app for Windows, macOS on Apple Silicon and Intel, and Linux.

  • Only where it pays off

    The MōBrowser API and Node.js cover most needs. Go native only for the parts that need it. Read the docs

AI automation

Let your AI agent run, use, and test your app

Writing code is only half the job. MōBrowser has a built-in automation server, so your coding agent can launch the real app, look at it, use it the way a person would, and check its own work before it hands the result back to you.

A coding agent builds a to-do app from one prompt, then runs it, tests every feature, and fixes the bugs it finds.
  • Agents know the framework

    Every new project includes AGENTS.md, skills, and the full MōBrowser docs. Agents use the real API instead of guessing, regenerate IPC bindings when needed, and know how to launch and check the app, so you don’t have to explain it in every prompt.

    App
    • .agents/skills/mobrowser-testing/
    • .claude/skills/mobrowser-testing/
    • .github/workflows/test.yml
    • src/main/
    • src/renderer/
    • test/e2e/
    • node_modules/@mobrowser/api/docs/
    • AGENTS.md ← read by your agent
    • package.json
  • Agents interact with your app

    Agents drive your actual app, not a separate browser, with no Playwright setup. The agent can do:

    • Accessibility snapshots
    • Screenshots
    • Click, type, select, keys
    • Console and network
    • Multiple windows
    • Native dialogs
    • Run JavaScript

    Run it interactively and watch the agent work in a visible window, or autonomously with a hidden window for unattended tasks.

    Headless Linux supported. Agents can run and drive your app on servers, CI runners, and cloud dev environments with no display attached.

  • Agents write E2E tests

    The agent keeps the checks it made as Playwright End-to-End (E2E) tests. A ready GitHub CI/CD workflow runs them on macOS, Windows, and Linux for every pull request, and keeps screenshots and traces of every failure.

    $ npm test

    Running 6 tests using 1 worker

    • ✓ opens the main window 1.2s
    • ✓ greets the user by name 0.8s
    • ✓ toggles dark mode in settings 1.1s
    • ✓ confirms before deleting a file 0.9s
    • ✓ exports the report to PDF 2.3s
    • ✓ restores the last opened window 1.4s

    6 passed (7.7s)

    CI ✓ macOS ✓ Windows ✓ Linux

MōIcons

Free & open source

Give your app an icon it deserves

Describe your app in plain words and MōIcons turns it into polished macOS icon options. Compare up to three directions, refine the best one in conversation, and export a real .icns with a full iconset. No design tool needed.

Built with MōBrowser by the MōBrowser team.

macOS 14 (Apple Silicon) or later. Generates with your ChatGPT account or an OpenAI or OpenRouter API key.

Features

Everything a modern desktop app needs

An all-in-one solution for teams that want to build a desktop app with a familiar web stack and ship it to users in months, not years.

  • Native installers, signed and ready

    Package your app into native installers with one command. Signing and notarization run automatically on every build.

  • Automatic updates

    Check, download, and install new versions with small delta updates. Host them on:

    • Your own server
    • Amazon S3
    • Google Cloud Storage
    • Cloudflare R2
  • Tray

    Live in the macOS menu bar and the Windows notification area.

  • Desktop notifications

    Show native notifications on Windows, macOS, and Linux.

  • Dark and light mode

    Follow the user’s system theme automatically.

  • Window customization

    Control how windows look and behave, and enter or exit full screen.

  • Native dialogs

    Native message and file dialogs on every platform.

  • Global shortcuts

    Keyboard shortcuts that work even when your app isn’t focused.

  • Menus and desktop integration

    Build the macOS application menu and native context menus with standard and custom items. Show a Dock badge, open links in the default browser, and reveal files in the file manager.

  • Downloads, clipboard, and preferences

    Manage file downloads and track their progress, read and write the system clipboard, and store app preferences on the local file system.

Enterprise support & SLA

Focus on your app.
We’ll take care of the framework.

Open-source frameworks leave you with community forums. With MōBrowser, the engineers who build the framework answer your questions, fix the bugs, and add the features you need, on a schedule you can plan around.

  • 4-hour response

    We answer within 4 business hours, backed by an SLA.

  • 2-day bug fixes

    We fix the bug you report within 2 days.

  • 1-week features

    We add the missing feature you need within a week.

  • Talk directly to the developers

    The product engineers handle every support request. Get as technical as you need to make MōBrowser work for you.

  • Communicate securely

    Private support channels keep everything about your project safe and strictly confidential.

  • Email, chat, or a video call

    Pick the channel that fits the problem, from a quick question to a deep debugging session.

  • Talk to developers

    Get technical help or share feedback with the MōBrowser team.

    Contact Engineers
  • Talk to sales

    Discuss your requirements, learn about pricing, or request a demo.

    Contact Sales

Security and compliance

Ready for the Cyber Resilience Act

MōBrowser is developed by TeamDev, a company headquartered in the European Union, and is itself within the scope of the EU Cyber Resilience Act. We build it to support the CRA work of the companies that ship apps with it.

Regulation (EU) 2024/2847 Read our CRA statement
  • SBOM for every app you build

    Generate a software bill of materials in CycloneDX format. It lists everything your app ships on each platform: Chromium, MōBrowser and its dependencies, and your production npm packages.

    Available since MōBrowser 2.15.0.

  • Timely security updates

    We track vulnerabilities in Chromium and other dependencies, follow Chromium releases closely, and prioritize critical fixes.

  • Fixes reach users fast

    Built-in automatic updates deliver security fixes without a reinstall. Updates can be signed, so only you can release them.

  • App integrity checks

    A signed app verifies its packaged sources at startup and refuses to run if they were modified after signing.

  • Open about vulnerabilities

    Fixed vulnerabilities are listed in the release notes. We follow a coordinated vulnerability disclosure policy.

Pricing

Free for non-commercial use. When you ship, pick an annual subscription that fits your stage of growth. It covers all updates and technical support, with no per-app fees.

Non-commercial Use

For learning, experiments, and personal projects.

Free
  • Keep what you build Applications built with the framework continue to work even if you stop development or cancel your subscription.

  • Unlimited projects

  • Standard license terms

Business Edition

For small business and agencies.

$8,000
  • Keep what you build Applications built with the framework continue to work even if you stop development or cancel your subscription.

  • Unlimited projects

  • Standard license terms

  • Support

  • 1 year of technical support

  • 3 accounts at MōBrowser Help Center

Enterprise Edition

Support for businesses operating at scale.

Custom
  • Keep what you build Applications built with the framework continue to work even if you stop development or cancel your subscription.

  • Unlimited projects

  • Custom license terms

  • Support

  • 1 year of technical support

  • Custom number of accounts at MōBrowser Help Center

The prices on this page are exclusive of any taxes.

FAQ

Answers to the questions teams ask before building with MōBrowser.

Comparison & Alternatives

Why should we choose MōBrowser over Electron or Tauri?

MōBrowser is designed for teams building commercial desktop applications, where reliability, security, and support matter.

With Electron or Tauri, your team is responsible for:

  • resolving framework-level issues;
  • relying on community support;

MōBrowser provides:

  • faster and more predictable updates;
  • technical support with SLAs;
  • private communication channels;
  • timely security updates.

If you’re shipping a product where downtime and risk have real cost, MōBrowser offers a more controlled and reliable foundation.

What problems does MōBrowser solve that open-source frameworks don’t?

MōBrowser focuses on the challenges that appear in production:

  • Security maintenance → managed Chromium updates and faster vulnerability fixes;
  • Operational risk → SLA-backed support instead of relying on community responses;
  • Intellectual property protection → stronger safeguards for distributed applications;
  • Maintenance overhead → less time spent on framework-level issues.

Instead of investing engineering effort into maintaining your stack, your team can focus on building product features.

Can we migrate an existing Electron app to MōBrowser?

Yes, in most cases. But it’s not a drop-in replacement.

  • Frontend code (React, Vue, etc.) is typically reusable;
  • Backend logic and IPC will need adaptation to MōBrowser’s architecture;
  • Node.js native modules you use in Electron will work in MōBrowser.

For mature Electron apps, migration is a strategic decision. Teams usually consider it when they want:

  • stronger security and intellectual property protection;
  • more predictable updates;
  • reduced long-term maintenance effort.

What frontend frameworks are supported?

MōBrowser works with any modern web frontend framework, including React, Vue, Angular, and Svelte.

Since MōBrowser is based on Chromium, it supports all the features and Web APIs that Google Chrome supports.

You’re not locked into a specific stack. You can use the tools your team already knows.

Can I integrate native code (C++/Rust)?

Yes. MōBrowser allows integration with native C++/Rust modules when you need:

  • high-performance components;
  • access to OS-level APIs;
  • integration with existing native libraries.

Pricing & Licensing

What is the difference between non-commercial and commercial use?

Non-commercial use applies to projects that are not used for business purposes, such as:

  • personal or hobby projects;
  • educational use;
  • open-source projects;
  • internal prototypes or experiments with no business value.

Commercial use applies when MōBrowser is used in any context that is part of a business activity or provides economic benefit.

This includes:

  • software that is sold, licensed, or distributed to customers;
  • internal tools used by employees as part of their job;
  • applications developed for clients or as part of paid services;
  • any use within a company or organization that contributes to its operations.

In short, if MōBrowser is used in a business context or as part of revenue-generating or operational activity, a commercial license is required.

If you’re unsure, it’s safest to assume your use is commercial or contact us for clarification.

Do we need a commercial license per developer, per app, or per company?

The license is issued to your organization, and the final pricing is determined by different factors such as:

  • number of applications or projects;
  • number of people interacting with support;
  • custom support requirements and legal terms.

This approach gives you flexibility to use MōBrowser across your team and products, while ensuring the license reflects your actual usage and support needs.

For exact terms and pricing, contact Sales. They’ll help define a model that fits your organization.

What does the commercial license include (support, SLAs, hotfixes)?

The license includes everything needed for production use:

  • access to MōBrowser and all updates;
  • security patches and bug fixes;
  • enterprise support with defined SLAs;
  • assistance from engineers when issues arise.

The goal is simple: your team should never be blocked by the framework.

What happens if we stop paying? Will our app continue to work?

All the apps you have developed with MōBrowser will continue to work.

How does MōBrowser reduce total cost of ownership (TCO)?

MōBrowser reduces the hidden costs of maintaining a desktop stack:

  • less time spent on Chromium updates and security issues;
  • fewer production incidents caused by framework-level bugs;
  • faster resolution when problems occur;
  • reduced need for specialized in-house expertise.

Instead of maintaining infrastructure, your team can focus on delivering product value.

Support & SLA

What does “enterprise support” actually include?

Enterprise support means you’re covered when it matters most.

  • help with real production issues;
  • guidance on architecture and best practices;
  • assistance during critical incidents;
  • ongoing access to product expertise.

Your team isn’t left figuring out platform problems on its own.

Who provides support?

You work directly with engineers who know MōBrowser.

  • no generic first-line support;
  • no long escalation chains;
  • faster, more precise answers.

When something breaks, you’re talking to people who can actually fix it.

What are guaranteed response times?

  • We respond within 4 business hours.
  • Business hours are Monday—Friday, 11:00 AM—7:00 PM (your time).
  • Communication channels are email, chat, video calls, and screen sharing.

Can we request features or custom fixes?

Yes. You can request features, suggest improvements, and discuss custom solutions with our engineers.

Do you offer onboarding or consulting?

Yes. We can help with setup and architecture, provide guidance on best practices, and support for complex use cases.

This helps your team get productive faster and avoid costly mistakes.

Security & Compliance

How does MōBrowser protect our source code and intellectual property?

MōBrowser is designed to make reverse engineering significantly harder than standard packaging approaches.

This is especially important for:

  • commercial desktop applications;
  • proprietary business logic;
  • licensed software distributed to customers.

While no client-side solution is fully unbreakable, MōBrowser helps reduce the risk of intellectual property leakage and protect your revenue.

How often is Chromium updated?

MōBrowser tracks Chromium closely and delivers regular updates aligned with Chromium releases.

This ensures your application stays:

  • up to date with modern web standards;
  • compatible with evolving web APIs;
  • aligned with the Chromium ecosystem.

How quickly are security vulnerabilities patched?

Critical vulnerabilities are prioritized and addressed as quickly as possible.

You benefit from:

  • reduced exposure window;
  • faster access to fixes;
  • less pressure on your team to react immediately.

This is especially important for teams operating in security-sensitive environments.

What happens if a critical bug is found in production?

You’re not on your own.

  • issues can be escalated through support;
  • critical problems are prioritized;
  • fixes are delivered as quickly as possible.

This reduces downtime and helps your team respond to incidents with confidence.

Does MōBrowser help with compliance (e.g., CRA, enterprise security)?

Yes. MōBrowser supports compliance efforts by providing:

  • timely security updates;
  • a controlled and maintained platform;
  • enterprise support with defined response processes.

While compliance depends on your full application and processes, MōBrowser helps you meet security and reliability requirements more easily.

See our CRA statement for more details.

Start building

Build your next desktop app with your AI agent

Create a project with one command and open it in your coding agent. It builds, runs, and tests the app, and MōBrowser turns it into signed installers for Windows, macOS, and Linux.

npm create mobrowser-app@latest
  • Free for non-commercial use
  • Agent-ready out of the box
  • Windows, macOS, and Linux