One Shared Core
A common foundation for application runtime, configuration, security, data access and essential services. Build new applications without rebuilding the same infrastructure.
Select Theme
APPNETOS · Application Internet Operating System
One Core.
Unlimited Business Software.
Build independent business applications on a shared foundation.
APPNETOS is a modular application platform built around one reusable Core. Create, extend and operate independent applications while sharing essential infrastructure, common capabilities and business functionality.
Build More. Maintain Less.
Why APPNETOS
A better foundation for business software.
Build applications around business requirements instead of repeatedly rebuilding the infrastructure beneath them.
Independent Applications
Install and configure applications independently, with their own routes, contexts and responsibilities. Share capabilities where needed without merging everything into one application.
Reusable Core Apps
Integrate existing functionality such as authentication, user management, permissions and localization instead of implementing it repeatedly across projects.
Extensible by Architecture
Customize application behavior through class extensions, mappings and application-specific implementations without modifying the shared Core.
Integrated Data & APIs
Build on MongoDB, Redis, reusable data models and integrated REST capabilities, including validation and OpenAPI generation.
Automation Built In
Run scheduled tasks and background operations with integrated workers, queues, retries and command-line tooling.
One Core. Many Applications.
One foundation. Different applications. Shared capabilities.
APPNETOS separates the shared platform Core from the applications built on top of it.
Each application can define its own runtime contexts, routing, configuration and functionality. At the same time, applications can integrate reusable Core Apps, shared services and business data where appropriate.
The result is an application ecosystem designed for independence without unnecessary duplication.
Explore the APPNETOS Philosophy
Built with APPNETOS
Real applications. One shared foundation.
APPNETOS is already used to build applications for development, infrastructure management and documentation. Each addresses different needs while relying on the same underlying Core.
APPNETOS API Dev
Explore, inspect and test generated OpenAPI specifications using Swagger-based tooling and integrated REST documentation.
APPNETOS DNS Control
Manage DNS and nameserver infrastructure with BIND9 integration, administration interfaces and background processing.
APPNETOS Docs
This documentation site is itself an APPNETOS application, built with reusable Core components and application-specific functionality.
Performance & Data Architecture
Less query plumbing. More application logic.
APPNETOS combines document-oriented data access with integrated caching capabilities to reduce repetitive database code and unnecessary operations.
MongoDB & Redis
MongoDB provides document-oriented persistence, while Redis supports caching and other shared runtime capabilities.
Document Cache
Integrated document caching helps avoid repeated database reads when cached document data can be reused.
Document & Collection System
Use structured PHP Documents and Collections to work with application data through consistent, reusable abstractions.
Nearly Queryless Development
Common data operations can be implemented without manually composing queries every time, while retaining flexibility for more complex requirements.
Efficient architecture provides the basis for performance; actual results depend on application workloads, data models and configuration.
Built for Developers
Less setup. Less repetition. More development.
A consistent foundation for building applications, from local development to reusable business functionality.
A Docker-based development environment and automated installer simplify setup. Application contexts, Core Apps, class extensions and integrated tooling establish patterns for everyday development.
Instead of assembling the same infrastructure for every project, developers can focus on the functionality their applications need.
Get StartedReproducible Setup
Docker-based development environment and automated installation.
Context-Based Applications
Clear boundaries for application, administration, REST and worker responsibilities.
Integrated Tooling
Command-line tools, REST and OpenAPI generation, and background workers.
Reusable Business Foundations
Shared Core Apps and Business Core data structures.
Version-Aware UI
Bootstrap-specific Core components organized by supported version.
Extensibility & Aliases
Class extensions and application aliases support adaptation and reuse.
A foundation designed to evolve.
Core UI components are organized by Bootstrap version. Existing applications can retain compatible implementations while support for newer versions is introduced separately, making framework evolution more manageable.
Multilingual by Design
Internationalization starts at the Core.
APPNETOS provides reusable language management, translation infrastructure and a prepared language template for international business applications.
81
Core translation languages
APPNETOS Core applications are supplied with translations for 81 languages, backed by a global English fallback.
438
Prepared language entries
The MongoDB language template provides 438 language and locale entries that can be enabled or reduced to fit an application.