Programming by intention, not implementation.
Intent Language (ITL) is an experimental open-source programming language designed to help developers build software by describing what they want instead of manually implementing every file, component, API, and configuration.
Rather than writing hundreds or thousands of lines of framework-specific code, developers write their intent, and the ITL compiler transforms that intent into complete applications.
ITL is not another AI coding assistant.
It is a programming language, compiler, and runtime that explores a new way of building software.
Imagine if programming was about describing your intentions instead of manually building every file.
Today, even with AI, developers still need to:
- Understand programming languages
- Create folders
- Organize project structure
- Configure frameworks
- Build APIs
- Connect databases
- Manage authentication
- Write frontend components
- Debug implementation details
AI makes coding faster.
ITL asks a different question.
What if developers only described what they wanted, and the compiler handled the implementation?
Instead of writing implementation, developers write intent.
Instead of creating dozens of React components, pages, configuration files, and routes, a developer writes:
app $Portfolio {
page $home {
theme $dark
hero $main {
image $assets/mypic.png
headline $Hi, I'm Abdulmumin
subtitle $AI Engineer & Founder
action $View Projects
}
section $about {}
section $projects {}
section $contact {}
section $footer {}
}
target $web
framework $react
}
The ITL compiler understands the application's intention and generates everything required to run it.
Programming has always evolved toward higher levels of abstraction.
Machine Code
↓
Assembly
↓
C
↓
Java
↓
Python
↓
Modern Frameworks
Each generation allows developers to focus less on implementation details.
ITL explores the next abstraction:
Developer Intent
Instead of describing implementation...
<div class="hero">or
<Hero />developers describe what the application should contain.
hero $main {
headline $Everything Fashion
subtitle $Buy from trusted tailors
action $Start Shopping
}
The compiler decides how that should be implemented.
The long-term vision of ITL is to become a language capable of describing applications through intent.
Developers should focus on:
- Business logic
- User experience
- Features
- Product ideas
instead of
- Framework configuration
- Boilerplate code
- Project organization
- Repetitive implementation
ITL follows one simple philosophy:
Developers describe WHAT they want.
The compiler determines HOW it is built.
Intent should be separated from implementation.
- Intent-first
- Human-readable
- Framework-independent
- AI-native
- Compiler-driven
- Extensible
- Modular
- Open Source
- Local-first
- Secure by default
Security is a core design principle of Intent Language (ITL), not an afterthought.
The language is designed to encourage secure application development by separating intent from sensitive implementation details.
ITL source files should never contain secrets.
Instead of embedding passwords, API keys, or tokens directly into .itl files, developers reference secrets that are resolved securely at runtime.
Example:
database $main {
provider $postgres
password env $DATABASE_PASSWORD
}
This allows the compiler to generate framework-specific implementations while keeping sensitive information outside the source code.
A .itl file should always be safe to:
- Commit to Git
- Share publicly
- Open source
- Review
Sensitive values belong in secure secret stores such as:
- Environment variables (
.env) - Cloud Secret Managers
- Vault providers
- Operating system credential stores
Applications should explicitly declare the capabilities they require.
Future versions of ITL may support capability declarations such as:
capabilities {
internet
storage
notifications
location
}
This allows generated applications to request only the permissions they actually need.
Security should be expressed once in ITL and implemented appropriately by each backend.
For example:
- React → Environment Variables
- Django →
os.environ - Flutter → Platform Secure Storage
- Future Browser Runtime → Secure Runtime APIs
The application intent remains the same regardless of the deployment target.
ITL aims to generate applications that follow secure defaults whenever possible, including:
- Separation of secrets from source code
- Safe project structures
- Minimal default permissions
- Deterministic project generation
- Validation during compilation
As the language evolves, security features such as secret providers, capability-based permissions, package verification, and secure runtime execution will become first-class parts of the ecosystem.
Intent should be public. Secrets should never be.
The language should:
- Read like a specification
- Be easy to understand
- Require minimal syntax
- Scale from simple websites to large applications
- Support multiple runtimes
- Support multiple frameworks
- Eventually support local AI execution
app $Portfolio {
page $home {
theme $dark
hero $main {
image $assets/mypic.png
headline $Hi, I'm Abdulmumin
subtitle $AI Engineer & Founder
action $View Projects
}
section $about {}
section $projects {}
section $contact {}
section $footer {}
}
target $web
framework $react
}
The ITL compiler currently follows this architecture.
Source (.itl)
│
▼
Lexer
│
▼
Parser
│
▼
Abstract Syntax Tree
│
▼
Semantic Analyzer
│
▼
Intermediate Representation
│
▼
Backend
│
┌────────┼────────┐
▼ ▼ ▼
React Vue Browser
Each backend receives the same Intermediate Representation (IR).
This allows ITL to target multiple frameworks without changing the language itself.
- Lexer
- Parser
- AST
- Semantic Analyzer
- Intermediate Representation (IR)
- Project Builder
- Command Line Interface
- React Backend (Work in Progress)
Explain an application
itl explain examples/appBuild a project
itl build examples/appGenerate a React project
itl dev examples/appintent/
├── examples/
├── itl/
│ ├── analyzer/
│ ├── backend/
│ ├── explain/
│ ├── ir/
│ ├── parser/
│ ├── runtime/
│ ├── pipeline.py
│ └── cli.py
├── spec/
├── README.md
└── pyproject.toml
A developer writes intent.
Developer
↓
ITL Source
The compiler validates the application.
Lexer
↓
Parser
↓
Semantic Analysis
The compiler transforms it into an Intermediate Representation.
IR
The selected backend generates the final application.
React
Vue
Flutter
Django
Browser Runtime
Modern AI coding assistants generate code from prompts.
However, developers still need to:
- Review generated code
- Organize files
- Manage architecture
- Configure projects
- Maintain implementation
ITL approaches the problem differently.
Instead of generating random source files from prompts, developers write a structured language that represents application intent.
The compiler then produces deterministic output.
Artificial Intelligence is expected to play an important role in the ITL ecosystem.
Rather than replacing developers, AI can become another backend that understands ITL programs and helps optimize, extend, or transform applications.
The language itself remains deterministic.
AI becomes an optional capability rather than a requirement.
- Language Specification
- Stable Compiler
- Browser Runtime
- Plugin System
- Local AI Runtime
- Multiple Framework Backends
- Package Manager
- Playground
- VS Code Extension
- Documentation Website
- Lexer
- Parser
- AST
- Semantic Analyzer
- CLI
- Intermediate Representation
- Project Builder
- React Backend
- Imports
- Multiple Pages
- Components
- Assets
- Plugins
- Theme System
- Layout Engine
- Developer Tools
- Browser Runtime Prototype
- Stable Language
- Official Specification
- Multiple Backends
- Package Registry
- Public Playground
ITL is an open-source research project.
The objective is to explore whether software can be developed by describing intent rather than manually implementing every detail.
We welcome contributions from developers interested in:
- Programming Languages
- Compiler Design
- Language Design
- AI
- Developer Tooling
- Documentation
- Runtime Systems
ITL is currently under active development.
The language syntax, compiler architecture, and runtime are expected to evolve as the project matures.
Contributions are welcome.
Whether you're interested in building the compiler, improving the language specification, designing developer tools, or experimenting with new ideas, we'd love to collaborate.
If you'd like to contribute:
- Fork the repository.
- Create a feature branch.
- Commit your changes.
- Open a Pull Request.
Please keep discussions respectful, constructive, and focused on advancing the language.
APACHE
Intent Language is inspired by decades of research in:
- Programming Language Design
- Compiler Construction
- Declarative Programming
- Domain-Specific Languages
- Human-Computer Interaction
- Artificial Intelligence
While influenced by these fields, ITL explores a distinct idea:
Programming should be about expressing intent, not managing implementation.
ITL is an experiment.
Perhaps it will evolve into a new programming paradigm.
Perhaps it will influence future developer tools.
Perhaps it will simply inspire new ideas.
Regardless of the outcome, the goal is to ask an important question:
What if programming languages were designed around human intention instead of implementation?
If that future is possible, we'd like to help build it.
Programming by intention, not implementation.