Distributed

Runtime

for

JS TS

Chop monolithic applications into micros
without touching a single line of code.

Introduction

Jitar is a full-stack JavaScript runtime for small to large web applications. It lets you build monolithic applications and run them spread out over multiple servers and web browsers. Jitar takes care of the inner communication, so you don't have to build any API.

Jitar runs on top of Node.js and in any modern web browser. It has strong support for TypeScript. You can use the frameworks you already love at the front- and back-end because it's only a runtime.

More detailed information about how it works and the philosophy behind it can be found in the docs.

client.ts
server.ts
server.segment.json
// Import components like it's a monolith
import { storePerson } from './server';
import { Person } from './Person';

async function createPerson(name: string, age: number)
{
    // Use components typesafe with Intellisense support
    // and exchange (complex) data objects between them
    const person = new Person(name, age);
    await storePerson(person);
}

export { createPerson }
// Use any library or framework you want
import { MongoClient as MC } from 'mongodb';
import { Person } from './Person';

async function storePerson(person: Person)
{
    const client = await MC.connect(process.env.DB_STRING);
    await client.db('my_app')
        .collection('people')
        .insertOne({ name: person.name, age: person.age });
}

export { storePerson }
/* Split applications with configuration */
{
    
"server.js": {
        
"storePerson": {
            
"access": "public", /* Control access */
            
"version": "1.0.0" /* Control versions */
        
},
        
"deletePerson": {
            
"access": "public",
            
"version": "1.0.0"
        
}
    
}
}

Benefits

Developers are at the heart of every application. Jitar is designed to make their lives easier and more productive.

API automation

API automation

Automates all client-server communication.

Configuration only

Configuration only

Keeping the code clean, simple and focussed.

Platform agnostic

Platform agnostic

Runs in modern web browsers and on the server.

Framework agnostic

Framework agnostic

Works with every frontend and backend framework.

E2E type-safety

E2E type-safety

Reduces programming and refactoring errors.

E2E Intellisense

E2E Intellisense

Speeds up developing highly scalable apps.


Features

The main feature is writing monolithic applications that scale in any form and closes the gap between front- and back-end. It doesn't matter if a component is placed on one of the servers or the web browser. Jitar will make it work using its powerful runtime features.

Segmentation

Segmentation

Applications are broken down into servable segment packages.

Learn more
Orchestration

Orchestration

Procedures always run, no matter the segment they're placed in.

Learn more
Load balancing

Load balancing

Segments that are served by multiple servers are balanced automatically.

Learn more
Access protection

Access protection

Private procedures are only available within its own segment.

Learn more
Multi-version

Multi-version

Procedures are versioned to support backwards compatibility.

Learn more
Transportation

Transportation

Data gets (de)serialized automatically when shared between segments.

Learn more
RPC calls

RPC calls

Public procedures can be called from any external system.

Learn more
And more ...

And more ...

There's also support for health checks, middleware, hooks and more.

Read the docs