TIBET Logo

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

Platform


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

TIBET is the first and only web platform to offer a true buy-vs-build solution: a full client stack, an optional server stack, a full tool chain, and full support from the vendor that built it all.


TIBET Solutions Description / Features
Client Stack The components every desktop-class application needs
Power Tools Immersive tooling built to keep you in the flow full-time
Server-Side Optional full-stack server and micro-service components
Server-less Serverless and desktop-based application configurations
Cloud Services Cloud-based services to offload application administration



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 more accurate, powerful, and flexible than TypeScript or ES6/7. Explore TIBET's client stack and you'll see similar wins in other layers:


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
Localization/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
URIs/Models URI data model caching with integrated change notification
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 XML support
Forms Accessible fields, groups, shortcuts, formatters, and validators
Widgets/Controls Tag-based components with d3, SVG, and other UI integrations


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



TIBET Power Tools

TIBET 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
Command Line (CLI) More than a task runner, a reflective development assistant
TIBET Sherpa™ Smalltalk-inspired browse/inspect/edit-while-it-runs IDE
Developer Console (TDC) Interactive client console enhanced with TIBET Shell
TIBET Shell (TSH) Unix-inspired tag-based shell with pipes, redirects, and more
TIBET Test Harness Single test harness for units, modules, and applications


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

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.

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 via the TDC or directly from your application code/UI.

The TIBET test harness doesn't rely on loading pages of tests 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.

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.




Server Options

TIBET Server Options

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) Modular, extensible Node.js+Express-based server
TIBET + CouchDB Full integration with CouchDB from couchapp to web app
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.



Serverless

Less Server...

We 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 serverless and desktop applications.


Desktop Option Description / Features
Serverless TIBET Applications leveraging AWS Lambda and similar services.
Desktop TIBET Desktop applications for Windows ®, Mac OS ®, and Linux ®


If you're going serverless, it's important to remember server cycles cost $, client cycles don't. An "offline first" framework like TIBET saves money, it's that simple.

If you're going desktop, a larger more powerful framework will pay dividends in terms of faster development and less custom code to maintain. Yeah, that money thing again.



Cloud Services

TIBET Cloud Services (Coming Soon)

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


TIBET Cloud Service Description / Features
Tag Store™ Think 'npm' for TIBET-related tags and components
TIBET Summit™ Hosted Sherpa, TIBET+CouchDB, and TIBET Workflow.


The Tag Store™ will provide an easy way to share tags across your internal projects or with the public TIBET community. The Tag Store will further extend TIBET's CouchDB integration and provide both Sherpa and CLI access to project tags and other resources.

TIBET Summit™ will let you deploy your full-stack TIBET applications (TIBET+TDS+CouchDB) 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.



The Pup

Contact us for more information or to discuss how we can assist you.