Introduction
Welcome to TIBET!
Why TIBET?
TIBET is unique in that it's optimized to:
- focus on the needs of desktop applications,
- support low-code authoring via smart markup,
- operate without reliance on an HTTP server,
- provide a complete, single-vendor solution.
TIBET delivers by seamlessly integrating a:
Let's take a closer look…
Desktop Harness
TIBET's Desktop Harness is a ready-to-rock application framework with:
- authentication/authorization via Okta, et. al.,
- configuration management for app, tool, and user settings,
- fast, flexibile loading and logging infrastructure,
- pluggable architecture for deep desktop integration,
- packaging and deployment for easy app distribution.
Create your new app in seconds with tibet clone:
tibet clone hello
cd ./hello
tibet init
tibet start
With TIBET you're running a deployable app in minutes.
Enhancing and testing your new app is immersive and easy:
- low-code Client Stack tags let you extend your base application,
- live patching and an In-App IDE let you develop on-the-fly,
- secure, scalable Data Server lets you mock, proxy, and more,
- runtime and ci/cd-ready Test Harness ensures code quality.
TIBET's integrated Command Tools handle deployment:
tibet lint
tibet test
tibet build --release
tibet deploy
Client Stack
Building for the desktop is different. There's no server to handle the logic, you need a full-strength application library to be successful.
TIBET was specifically designed to support full-strength application functionality, not just the thin UX layer typical of most web libraries.
Fully integrated and fully supported, the Client Stack includes:
- Configuration
- -- Unified configuration system for the full TIBET stack
- Loading
- -- Dynamic multi-phase loader with shared metadata
- Logging
- -- Extensible object-oriented logger with leveling
- Primitives
- -- Portable platform isolation layer for JS, DOM, CSS, XML
- OO & Traits
- -- Smalltalk-inspired inheritance coupled with traits
- Signals & Exceptions
- -- State / route / responder signaling and exceptions
- State Machines
- -- Nestable state machines w/ controller integration
- I18N
- -- Extensible Locales plus native type parsing / formatting
- Devices
- -- Keyboard mapping, key sequences, mouse gestures, D&D
- Services
- -- Request / Response processing for sync/async Services
- Users & Roles
- -- vCard-based user, role, unit, org support with keyrings
- URLs & URNs
- -- URI-based state management with change notification
- Content
- -- Powerful OO classes for the DOM, XML, and JSON
- Queries & Paths
- -- CSS queries, JSONPath, XPath, and xpointer() support
- Templating
- -- Full tag templating with integrated data formatters
- Data Binding
- -- Single and bi-directional binding with nested scopes
- Routing & History
- -- Signaling-based router with full history integration
- Tag System
- -- Type-driven multi-phase tag processing with XML support
- Forms & Fields
- -- Accessible fields, groups, formatters, and validators
- UX Base Tags
- -- Custom tag supertypes supporting d3, SVG, et. al.
In-App IDE
Lama™ is our interactive in-app IDE.
Unlike file-centric tools which rely on a bottom-up edit/reload cycle, Lama is tag-centric and operates top-down on your running application through direct manipulation.
Feedback is immediate and immersive with the Lama.
With Lama you simply select a tag you want to edit and go to work:
Lama innovates in a number of areas:
- interactive, top-down development with zero reload/compilation downtime,
- extremely fine-grained editing focused on tags and their behavior,
- add new tags, types, and more without leaving your running application,
- source edits sync bi-directionally between client and server without reload,
- extensible development library supporting new inspectors, editors, etc.
Some of that may sound familiar but we invite you to take a closer look.
Data Server
The TIBET Data Server is a penetration-tested server capable of full production use.
For Desktop application development, the Data Server can be used out-of-the-box to mock remote Cloud APIs or local endpoints in seconds.
Once you're ready to test against live services flip a config flag and your endpoints shift from mocks to routes targeting your configured services.
If you're building a new web application or web site, TIBET's server configurations are secure, production-ready, and used in a number of installations.
Regardless of your specific requirements, TIBET makes it easy to mock, develop, and deploy new APIs, web sites, or web applications out-of-the-box.
Command Tools
TIBET's Command Tools support the entire development and deployment (devops) lifecycle with a focus on ease-of-use and eliminating anything that interrupts flow.
The TIBET CLI runs commands but it also runs your application; reflecting on it, testing it, interacting with it to provide functionality guided directly by your application's code.
As with all of TIBET, TIBET's Command Tools are fully-integrated, leveraging TIBET's configuration system, reflection metadata, and each other, to optimize your workflow.
Extending the CLI is easy by adding your own commands or tibet make targets.
TIBET even supports writing your own app documentation manpages.
Summary
As mentioned earlier, we believe TIBET is the best business choice for creating cross-platform, mission-critical business applications.
With unmatched scope and integration, TIBET makes creating desktop applications easy.
Try TIBET.
We think you'll agree.
