Breaking down the walls: making Cardano more developer-friendly

Cardano's mathematical foundations and formal verification approach have established it as a leader in blockchain security and reliability. However, these same architectural choices that ensure exceptional security have created a developer experience that requires significant upfront investment in specialized knowledge, tools, and infrastructure. The result is a paradox: one of the most technically robust blockchains has remained challenging for many developers to build on, limiting ecosystem growth despite its strong technical advantages.

Recognizing this opportunity, Input | Output (IO) is developing Project Acropolis – a fundamental reimagining of the Cardano node architecture. Instead of treating the node as a fortress that applications must interface with from the outside, Acropolis transforms it into a modular, extensible ecosystem where developers can build applications from within using familiar tools and standard interfaces. This approach preserves Cardano's security guarantees while dramatically reducing barriers to entry.

Meet Alice: why her Cardano onboarding challenge matters to everyone

To understand what this transformation means in practice, let’s follow Alice, a fictional composite character representing many Rust developers with DeFi experience. This hypothetical scenario illustrates common challenges developers face when approaching Cardano development.

Attracted by Cardano's mathematically guaranteed security, she wanted to build a yield farming tracker – exactly the kind of financial application that benefits from Cardano's rigorous approach.

In our hypothetical scenario, Alice might reflect: 'The security model was compelling, but I encountered a learning curve that made quick prototyping challenging. I would have needed to invest significant time in learning Haskell and specialized protocols before becoming productive.'

Alice's experience highlights an opportunity: while Cardano provides unmatched security guarantees, developers wishing to integrate with the node may experience a steeper learning curve than with other blockchains, which may be discouraging.

Note: While smart contract developers now have Aiken as an alternative programming language to learning Haskell and Plutus, developers who want to integrate their backend systems with the Cardano node don't yet have this same type of accessible pathway. That’s what Project Acropolis is addressing. 

What if there was a way to preserve Cardano's technical advantages while providing familiar development interfaces?

Cardano's developer evolution

Decentralization, robust governance, and mathematically verified security make Cardano one of the most trusted blockchains. This is a result of deliberate architectural choices that prioritize security and correctness, which also create opportunities to improve developer experience.

While Cardano's emphasis on formal methods provides exceptional security guarantees, it also means developers need specialized knowledge to be productive. Paul Clark, IO’s lead architect working on developer experience improvements, describes the current architecture as having a ‘citadel mentality’ – exceptionally secure, but with limited entry points.

Today's development experience includes several areas ripe for improvement:

• Infrastructure requirements: accessing Cardano data through DB Sync requires up to 64GB of RAM and significant cloud hosting costs
• Interface complexity: custom networking protocols require specialized knowledge compared to standard REST APIs
• Specialized expertise: core development leverages Haskell, requiring dedicated learning time
• Architectural constraints: the unified node design prioritizes reliability but limits extensibility.

This points to a challenge: how to preserve Cardano's technical advantages while making development more approachable?

The game-changing vision: when the node becomes the ecosystem

This is exactly the problem Paul Clark and his team at IO are tackling with project Acropolis – an initiative to redesign the Cardano node with a modular architecture, enabling greater node diversity, easier integration, and more decentralized development. Their solution goes beyond making Cardano easier to access – they're fundamentally reimagining what a blockchain node can be.

‘We talk about the node’s ecosystem – all the applications and interfaces around it, like Cardano DB Sync, Ogmios, and Blockfrost. In my analogy, you've got the citadel in the middle and buildings around it. But my vision is that the node becomes sufficiently porous so you can build applications directly into the node, not just next to it, but actually part of it.’ 

This is the fundamental insight: the node IS the ecosystem.

Instead of applications struggling to interface with the blockchain from outside, they become part of the node infrastructure. Application functionality becomes embedded in the architecture. For example, decentralized exchange (DEX) protocols become part of the data processing pipeline.

Clark's vision transforms the node from a fortress into a living ecosystem where innovation happens from within.

How modular architecture changes everything

The technical foundation enabling this transformation is a ‘modular, event-driven architecture’ built on Caryatid, an application-independent framework that enables this modularity by providing message buses, module loading, and configuration management. It allows modules to run efficiently within a single process or be distributed across multiple processes for scalability, all without changing application code. Think of it as replacing an ancient citadel with a modern city district – specialized buildings instead of high walls and a single drawbridge. It’s more about buildings with interconnected pathways and roads – a network of buildings. 

From citadel to ecosystem

The current Cardano node is monolithic – a single, complex system handling everything in one package. Acropolis breaks this into loosely coupled modules that communicate through message buses and can be mixed, matched, and extended.

Key innovations:

• Standard interfaces: familiar REST or gRPC APIs instead of custom mini-protocols
• Modular components: run only the modules you need
• Polyglot development: interface in any language while the core framework uses Rust
• Event-driven architecture: subscribe to relevant events instead of polling for changes
• Custom extensions: write your own modules and get direct access to everything happening inside the node.

Real impact: who's already excited

Real projects addressing real pain points are already lining up to use Acropolis.

Partner chains plan to embed cross-chain logic directly into Acropolis nodes instead of using existing generic and inefficient indexing solutions.

Blockfrost currently runs expensive infrastructure to make Cardano data accessible. With Acropolis, they could dramatically reduce costs while improving performance.

Sundae Labs is also looking at Acropolis’ modularity, and has some exciting plans to leverage that to upgrade the ‘Scooper’ software, which batches and executes orders, and as a key component of several other projects they have in the works.

The real excitement comes from projects that don't exist yet – applications that become possible when infrastructure barriers disappear.

Timeline and current status

Project Acropolis, which began in October 2024 with Paul Clark working on the Caryatid framework, is in the ‘early explorer phase’ – a small team proving the vision is technically feasible. While the project now includes Sundae Labs developers and other Cardano engineers, the team remains deliberately small.

• Phase 1 – data node (current): building foundational infrastructure and replacing DB Sync with modular, REST-accessible components
• Phase 2 – validating node (2nd half of 2025): adding transaction validation and script execution
• Phase 3 – full node (future): block production and multi-peer networking.

‘You go out there and try anything – it's like skunk works where you experiment, and if something breaks, you iterate. Think of early explorers mapping rivers, mountains, and bogs, clearing jungle to find the path. The next phase is stabilization: making it habitable with flexible design, establishing methodology while keeping it adaptable. We're proving this technology works this particular way, but it's not the only approach. You could do it completely differently, and the cost wouldn't be a complete rewrite because it's modular.’

Re-imagining Alice's experience with Acropolis

Let's revisit our hypothetical scenario with Alice, but this time imagine her development experience with Acropolis available as an option.

In this scenario, when Alice decides to build her yield farming tracker, she discovers that Acropolis documentation offers a different approach: REST API endpoints for liquidity pool data, standard subscription methods for real-time updates, and examples across multiple programming languages. 

She finds herself working with familiar patterns – HTTP requests and standard web technologies. Within hours, she has basic pool data flowing into her Rust application. By day's end, she's prototyped a notification system using transaction event subscriptions.

The experience reveals a possibility: rather than building an isolated external application, Alice could contribute a ‘yield analytics module’ that becomes part of the broader ecosystem. This modular approach means other developers could build on her work, extending it or using it as a foundation for their own projects.

Her focused weekend effort could become reusable infrastructure, potentially accelerating future development for the entire community.

The bigger picture: opening the floodgates

The real promise of project Acropolis isn't just making Cardano development easier – it's fundamentally expanding who can participate in the Cardano ecosystem.

When blockchain infrastructure becomes as accessible as web development, building on Cardano feels as natural as building a REST API, and applications can live inside the ecosystem instead of struggling to interface with it from the outside, that's when the community will realize the true potential of decentralized ecosystems.

While the technical barriers served their purpose in establishing security, they also created unintended obstacles for developers like Alice, limiting growth potential. Paul Clark's vision of the node-as-ecosystem represents a path toward the best of both worlds: maintaining Cardano's mathematical rigor and security while opening the doors to a vastly larger community of builders. 

For developers who've been waiting for the right moment to explore Cardano, that moment may be approaching faster than expected. The walls are coming down, and the ecosystem is about to get much bigger.

Project Acropolis is currently in active development. Developers interested in following the project or getting involved can track progress through IOHK’s blog. 

Follow Paul Clark on X: @towlenner

See Acropolis and Caryatid GitHub repositories.