Welcome to Jitar, a distributed runtime for JavaScript and TypeScript that lets you build your application as a monolith and deploy it as (micro)services by configuration.
Jitar runs on the server and the web browser, closing the gap between the frontend and backend. All end-to-end communication is automated with type-safety. You can call your server functions directly, Jitar takes care of the rest.
In contrast to other solutions, there is no trace of Jitar in the application code, ensuring platform and framework agnosticism for easy integration and safety.
🏁 Try Jitar: see our Quick Start
⭐ Give us a star to show your support.
👋 Have questions? Join our discord community.
Building scalable applications is hard. It requires breaking an application into independently deployable pieces, like microservices. The boundaries of these pieces are sensitive to change and aren't always clear. Developing endpoints and requests to arrange the communication between them brings a lot of overhead.
Jitar is designed to solve these problems. It makes the boundaries configurable so you can change them painlessly at any time and eliminates the overhead by automating the end-to-end communication.
For breaking applications into distributable pieces, Jitar uses a segmentation system. A segment defines what functions need to be deployed together. Jitar connects these segments by creating RPC endpoints and requests under the hood.
Developers are at the heart of every application. Jitar is designed to make their lives easier and more productive.
- API automation - Automates all client-server communication.
- E2E type-safety - Reduces programming and refactoring errors.
- Configuration only - Keeping the code clean, simple and focussed.
- E2E Intellisense - Speeds up developing full-stack apps.
- Platform agnostic - Runs in modern web browsers, servers and on the server.
- Framework agnostic - Works with every frontend and backend framework.
Build a monolith, deploy as microservices. Jitar provides powerful features to scale endlessly.
- Segmentation - Breaks down applications into deployable packages.
- Orchestration - Coordinates running segmented procedures.
- Load balancing - Balances the execution of procedures automatically.
- Access protection - Protects the access to private procedures.
- Transportation - (De)serializes data automatically.
- Multi-version - Supports multiple versions of the same procedure.
- Integration - Integrates in any existing landscape.
- And more - Validation, health checks, middleware, hooks, etc.
Jitar is a great tool for building applications that are expected to grow and change over time. It can be used for building small to large API driven (web) applications, like:
- Full-stack applications
- Microservices
For existing applications, Jitar can be of great assistance for load balancing (parts) of the application, or adding multi-version support.
Getting started with Jitar is as easy as pie. It only takes a few simple steps.
- Create new project - Start fast with our creator and pick one of our templates for Vue, React, SolidJS and more.
- Add your functions - Write functions and export them like you are used to.
- Configure what runs on the server - Add the exported functions to a server segment configuration file.
- Run your application - Jitar will take care of the rest.
Full documentation is available at docs.jitar.dev.
Please join our Discord community for questions and discussions.
- How I Speed Up Full-stack Development by Not Building APIs
- How I Split a Monolith Into Microservices Without Refactoring
We welcome contributions to Jitar. Please read our contributing guidelines for more information.
A special thanks to everyone who has contributed to Jitar so far!
We are working hard towards a stable 1.0 release. Details can be found in our roadmap document.