TIBET: The Sum Of The Parts, Not Some Of The Parts™

The full stack, fully supported. Nothing else comes close.

With scope you won't find in any other web platform, TIBET is truly "The Sum Of The Parts, Not Some Of The Parts™" No other platform offers you TIBET's complete buy-vs-build solution.

Starting with a client/server architecture that's perfect for the Cloud, TIBET provides a full client stack, an optional server stack, a full tool chain, integration with Electron for Desktop development, all with full support from the vendor that built it…us.

TIBET Solutions

Topic Description / Features
Client Stack The components every desktop-class application needs
Server Stack Optional full-stack server and micro-service components
Power Tools Immersive tooling built to keep you in the flow full-time
Desktop TIBET Cross-platform desktop-based application configurations
TIBET Cloud Cloud-based components and services for your applications

TIBET Tutorials

Topic Description
TIBET Quickstart Hello World! TIBET-style
TIBET Essentials Hello World! Part Deux
TIBET Deployment Deploying TIBET applications

Special Topics

Topic Description
TIBET and React Using React widgets from TIBET markup
TIBET and ECMA classes Using ECMA-6 classes with TIBET OO
TIBET Short Topics A few miscellaneous TIBET topics
TIBET Troubleshooting Dealing with unexpected errors
TIBET Standards Web and coding standards, TIBET for JS coders

Manual Pages

Topic Description
TIBET Manpages Command line and other manual pages

TIBET Client

The TIBET Client

TIBET started out as a pure client platform but it's not your typical client. In fact, we'd venture to say TIBET is unlike any other web client you've experienced. We think that's a good thing.

Many of the terms we might use to describe TIBET will sound familar: tag-based, MVC, OO, event-driven; however, TIBET's implementation often goes far beyond the typical definition. For example, TIBET's OO implementation is easier and yet more accurate, powerful, and flexible than TypeScript or ES6/7. Explore TIBET's client stack and you'll see similar wins in other layers.

Additional TIBET modules cover a variety of enterprise standards your projects may require including JSON Schema, XML Schema, XSLT, XMPP (chat), vCard, and more.

Client Layer Description / Features
Configuration Unified configuration system for client, server, CLI, and tools
Loading Dynamic multi-phase loader with shared metadata for tools
Logging Extensible object-oriented logger with Log4Java 2.0 APIs
Primitives Portable browser isolation layer for JS, DOM, CSS, and XML
OO & Traits Smalltalk-inspired inheritance coupled with composable traits
Signals & Exceptions State / route / responder-aware signaling and exception handling
State Management Nestable state machine support with app controller integration
I18N Extensible Locale types plus native type parsing / formatting
Devices Keyboard mapping, key sequences, mouse gestures, D&D
Services Request / Response processing for sync/async Service types
Users & Roles vCard-based user, role, unit, org support with client keyrings
URLs & URNs URI-based state management with integrated change notification
Content Powerful object-oriented classes for the DOM, XML, and JSON
Queries & Paths CSS queries, JSONPath, XPath, and xpointer() support
Templating Full client-side templating with integrated data formatters
Data Binding Single and bi-directional binding with nested scopes / repeats
Routing & History Signaling-based router with full browser history integration
Custom Tags Type-driven multi-phase tag processing with full XML support
Forms Accessible fields, groups, shortcuts, formatters, and validators
Widgets & Controls Tag-based components with d3, SVG, and other UI integrations

Server Options

TIBET Server

If you're not in the market for server-side technology don't worry, the TIBET client works with any HTTP or WebDAV server, "serverless", or with no server at all via Electron or file: URLs.

TIBET is server-agnostic to the point of being fully server-independent.

Of course, if you're looking for a full-stack solution we believe TIBET offers you the most complete, integrated, and supported stack available…along with a few bonus options:

Server Option Description / Features
TIBET Data Server (TDS) Pluggable, extensible Node.js + Express-based server
TIBET + CouchDB Integrated CouchDB support from web app to couchapp
TIBET Workflow System (TWS) Powerful, flexible, state-persistent microservice engine

Some features of the TIBET Sherpa rely on the TDS (file watch, file patch, etc) to work effectively but you can use the TDS's built-in proxy plugin, nginx, or a similar product during your development phase. The TDS is not required for production.

TIBET Power Tools


TIBET's tools support every core development/deployment task with a focus on ease-of-use and eliminating anything that interrupts flow. We know they work, we use them daily to develop both TIBET and the TIBET-based solutions we create for our clients.

TIBET Tool Description / Features
TIBET Sherpa™ Smalltalk-inspired browse / inspect / edit-while-it-runs IDE
Developer Console (TDC) Interactive client console enhanced with TIBET Shell
TIBET Shell (TSH) Tag-based command shell with pipes, redirects, and more
TIBET Test Single test harness for units, modules, and applications
Command Line (CLI) More than a task runner, a reflective development assistant

You may be thinking you've seen tools like these before…but take another look.

The Sherpa™ isn't yet another file-centric editor that runs in a browser, it's a fine-grained, tag-centric development environment inspired by Smalltalk's unmatched ability to develop your application while it runs. There's no "preview" button in the Sherpa…your app is live.

The TDC doesn't just evaluate JavaScript, it runs TIBET Shell (TSH), a revolutionary tag-based shell whose scripts can be run interactively or triggered from your application code/UI.

The TIBET test harness doesn't rely on loading pages of functions disconnected from the objects they test, it associates your tests with objects, providing a more focused approach to testing and coverage tracking you can use from the Sherpa, the CLI, or within your CI/CD pipeline.

The TIBET CLI doesn't just run tasks…it runs your application and reflects on it, tests it, interacts with it while it runs, to provide functionality you can't get from a simple task runner.

From the TIBET CLI to TIBET Sherpa™, TIBET's tools are fully-integrated, leveraging TIBET's configuration system, reflection metadata, and each other, to optimize your workflow.


TIBET Desktop

We initially built TIBET by launching it from the file system rather than an HTTP server in part to ensure we never became dependent on application servers that would be unavailable should the network fail. This approach means TIBET is not just server agnostic, it's server independent.

Server independence makes TIBET perfect for desktop applications.

Desktop Option Description / Features
Desktop TIBET Desktop applications for Windows ®, Mac OS ®, and Linux ®

If you're going desktop, TIBET's scope of functionality pays dividends in terms of faster development and less custom code to maintain…saving you time and money.

Cloud Services


TIBET's unique Client/SOA design allows it to work more efficiently with serverless architectures, making TIBET an extremely cost-effective option for serverless applications.

To further streamline development and deployment of TIBET applications we also have two Cloud services planned for release in mid-to-late 2019, the TIBET Tag Store™ and TIBET Summit™.

TIBET Cloud Service Description / Features
Serverless TIBET Applications leveraging AWS Lambda and similar services.
TIBET Tag Store™ Think public/private 'npm' specific to TIBET tags and components.
TIBET Summit™ Hosted Sherpa, TDS, TIBET+CouchDB, and TWS configurations.

The Tag Store™ is designed to let you share TIBET tags, models, and controllers across your internal projects or with the public TIBET community. The Tag Store provides both Sherpa and CLI access to project tags and other resources.

TIBET Summit™ is designed to let you deploy your full-stack TIBET applications directly to a set of hosted servers configured specifically for TIBET. With Summit you'll also be able to leverage the Sherpa to develop and deploy changes directly from the Cloud.

TIBET Standards

TIBET Standards

TIBET isn't your typical JavaScript platform. Written to take advantage of existing standards and developed with a strong set of internal coding standards and conventions, TIBET is unlike any other platform we've encountered in our over twenty years developing web applications.

TIBET Standards Description / Features
TIBET for JS Programmers TIBET differences from typical JavaScript
TIBET Conventions Coding conventions for your TIBET code
TIBET Coding Standards The coding standards used in TIBET itself
TIBET + Web Standards TIBET is highly web standards-compliant


As always, we appreciate any feedback you may have about our documentation, what subjects you would like to see covered in more detail, etc. Contact us with any input you may have!