Inca Ultrachain is a Layer 1 EVM blockchain with a native on-chain database, AI agent infrastructure, and protocol-level application primitives. One contract. Full-stack dApp. Zero external dependencies.
Today's EVM ecosystem forces developers to juggle 5+ disconnected tools to ship a single application. We built the fix at the protocol level.
Solidity + React + The Graph + Infura + IPFS. Each with its own pipeline, versioning, and failure modes. Maintenance hell.
Solidity mappings can't iterate. Want to list users? Deploy a subgraph. Wait 15 minutes. Pay monthly hosting. Hope it doesn't break.
Agents need memory, identity, cheap state access. Current chains offer none of this natively. Agents are afterthoughts, not citizens.
Your "decentralized" app runs on Vercel, Alchemy, and AWS. One outage and your dApp goes dark. True decentralization is a myth.
Everything a full-stack dApp needs — built into the chain. No middleware. No external services. No compromises.
Structured tables with typed schemas, secondary indexes, range scans, cursor pagination. Protocol-level. No subgraphs.
OperationalCREATE_TABLE, GET, PUT, DEL, EXISTS, INDEX_SCAN, TABLE_INFO. Native EVM precompiles at 10-100x lower gas than SSTORE.
OperationalByte-identical encoding across all nodes. 12 column types. Max 2048 bytes/row. Big-endian canonical. Verifiable state.
OperationalGenesis system contract for dApp discovery. Register, search, categorize, resolve by name. Permissionless. On-chain.
OperationalsuperDb_* and super_* namespaces. Direct database reads and app resolution without EVM transactions. Cheap. Fast.
OperationalNative table, theme, ui route constructs. 1 file = backend + database + frontend. Compiles to standard EVM bytecode.
In DevelopmentSolidity was designed for token logic. Solidity++ extends it into a true application language — with native syntax for databases, themes, and UI routes. One file. Backend + Database + Frontend. Zero external tooling.
In traditional Solidity, you use mappings — flat key-value stores that can’t iterate, can’t query by secondary fields, and can’t paginate. To list your users or filter by status, you need The Graph — an external service with its own infrastructure, deployment pipeline, and monthly costs.
Solidity++ introduces the table keyword. Define typed columns, mark a primary key, add indexes on any sortable field. The compiler generates precompile wrappers that store data in the protocol’s native table engine — not in EVM storage slots.
Exactly one field marked primary. Used for direct reads (DB_GET) and writes (DB_PUT).
Fields marked index enable range scans, ordering, and filtering — natively, at protocol level.
DB_PUT costs ~2,000 gas vs 20,000+ gas for SSTORE. 10x cheaper writes.
Today, every dApp needs a separate React/Next.js frontend — hosted on Vercel, Netlify, or IPFS. Your “decentralized” app depends on centralized servers.
Solidity++ introduces ui route — a Flutter-inspired widget tree that compiles to a compact binary format (UI-IR) embedded directly in the contract bytecode. It’s NOT executed on-chain. A standard SuperClient reads the UI definition and renders it.
Page, Column, Row, Card, Text, Stat, InputUint, InputText, Button, Table, Col, Spacer/Divider.
Use tx.*, view.*, db.*, input.*, nav.*, fmt.* to bind UI to contract logic.
No server. No IPFS. The UI lives in the contract bytecode. Truly decentralized applications.
Every dApp needs a consistent look. Instead of CSS files scattered across repos, Solidity++ lets you define your entire design system inside the contract.
Colors, fonts, spacing, border radius, shadows — all defined with typed tokens. The theme is embedded in the contract bytecode and used by the SuperClient to render a polished, consistent UI.
Color, Font, Spacing, Radius, Shadow — all compile-time validated. No typos. No missing values.
Theme is embedded in bytecode alongside UI-IR. No separate CSS deployment pipeline.
Every SuperClient renders the same visual output. Same tokens, same result. Verified on-chain.
Not mappings. Not events. A real database built into the blockchain protocol — with tables, typed schemas, secondary indexes, range scans, and cursor pagination. Try it below.
Data is stored in a separate Table State domain, not in EVM storage slots. This means: no state trie bloat, predictable gas costs, and bounded query execution. Every row is encoded with RowCodec v1 — deterministic, byte-identical across all nodes.
Want to list users by balance? Just call INDEX_SCAN. No deploying a subgraph. No waiting 15 minutes for indexing. No $50/month hosting. It's built into the protocol.
A platform where you enter any contract address and it renders the app — no frontend repo, no hosting, no build pipeline. The contract IS the application.
| ID | Title | Goal | Pledged | |
|---|---|---|---|---|
| 1 | DeFi Optimizer | 50 ETH | 32 ETH | Open |
| 2 | NFT Marketplace | 100 ETH | 87 ETH | Open |
| 3 | DAO Toolkit | 25 ETH | 25 ETH | Open |
The SuperClient is a universal dApp renderer. It reads the UI-IR (compact binary widget tree), Schema (table definitions), and Theme (design tokens) — all embedded in the contract bytecode — and renders a fully interactive application.
User enters a contract address or AppID. SuperClient calls super_getAppManifest to resolve the app.
SuperClient reads UI-IR, Schema, and Theme from the bytecode trailer (SSOL magic bytes). No external servers.
The widget tree is rendered with the contract's theme. Data bindings connect to view functions and DB queries.
User actions (buttons, forms) become blockchain transactions via tx.* bindings. Wallet signs. Protocol executes.
Write a single .solpp file. The SuperSolc compiler transforms it into EVM bytecode with embedded metadata sections. Deploy once. App is live forever.
Backend + DB + UI
in one file
Compiles table, theme,
ui route constructs
Standard EVM +
SSOL trailer
Deployed forever.
Fully decentralized.
See how many tools, repos, and services you can eliminate.
The first L1 where AI agents have native identity, persistent on-chain memory, scoped permissions, and economic coordination. Built into the protocol. Not bolted on.
SuperChainDB gives agents what no other chain can: structured tables for memory at precompile-level gas costs. Agents that remember, learn, and earn — all verifiable on-chain.
On-chain identity: name, capabilities, model hash, reputation, staked collateral. Discoverable by any dApp or user.
Persistent structured memory via SuperChainDB. Agents remember across sessions. Verifiable. Auditable. 10-100x cheaper.
Smart wallet per agent: spending limits, allowed contracts, daily budgets, emergency freeze. Owner controls, agent executes.
Post tasks with rewards. Agents bid, execute, get paid. Built-in reputation scoring and dispute resolution.
Delegate to agents with fine-grained permissions: contracts, tables, spending caps, expiration. Revoke anytime.
Shared on-chain message tables. Topic-based messaging. Task delegation between agents. Collaborative workflows.
Five layers. Every one extends EVM with native primitives that don't exist on any other chain.
Traditional EVM: 5 repos, ~2000 lines, monthly fees, external indexers. Inca Ultrachain: 1 file, ~100 lines, zero dependencies.
Solidity++ extends Solidity with native constructs for structured data, declarative UI, and theme systems. Compiles to EVM bytecode with embedded metadata sections.
| Feature | Traditional EVM | AI Chains | Inca Ultrachain |
|---|---|---|---|
| On-Chain Database | Mappings (no iteration) | None | Native tables, indexes, scans |
| AI Agent Memory | Off-chain (Redis) | Off-chain | On-chain structured tables |
| Agent Identity | EOA only | Custom protocols | Native registry + smart wallets |
| dApp Discovery | Off-chain dirs | Manual config | On-chain AppRegistry |
| DB Write Cost | 20,000+ gas | N/A | ~2,000 gas (precompile) |
| Full-Stack dApp | 5+ repos, 5+ tools | Not supported | 1 file (Solidity++) |
| Agent Coordination | None native | Off-chain | On-chain task marketplace |
Real progress, not promises. Core infrastructure is built and tested.
Frontier EVM, pallet-evm, pallet-ethereum, BaseFee, ChainId 42069, Hardhat test suite. Full Ethereum RPC compatibility.
Completedpallet-table-state: tables, rows, indexes, range scans. 7 DB precompiles. RowCodec v1 deterministic encoding. 80+ tests.
CompletedsuperDb and super RPC namespaces. AppRegistry system contract at genesis. Discovery, categories, search, pagination.
CompletedAgentRegistry, AgentWallet, TaskMarketplace contracts. Delegation precompiles. On-chain memory. Agent RPC namespace.
In Progresssolc 0.8.28 fork: table, theme, ui route syntax. AST extensions, semantic analysis, precompile codegen, UI-IR compiler.
UpcomingPublic multi-validator testnet. TypeScript + Python agent SDKs. Templates. SuperClient renderer. Wallet integrations.
UpcomingEarly supporters get INCA tokens at the lowest price. Funds go directly to protocol development. No VC gatekeeping.
This is not a whitepaper project. The testnet is fully operational — with EVM integration, native database engine (SuperChainDB), 7 DB precompiles, custom RPC endpoints, AppRegistry, and 80+ automated tests passing. The core infrastructure is built and battle-tested.
The presale funds go directly to mainnet development: multi-validator infrastructure, AI agent layer, SuperSolc compiler, public testnet, SDKs, and security audits. No VCs, no middlemen — community-funded from day one. Every token sold accelerates the launch.
Genesis round participants get INCA tokens at the lowest price before mainnet launch. Once the mainnet goes live, the token will be listed at a significantly higher price. This is your chance to secure early allocation at a fraction of the launch price.
Be part of the first AI-native EVM blockchain. Early access. Best allocation. Validator priority.
Enter Presale Allocation is limited