Hello everyone! I’m Vinit Shinde from Pune, currently in my final year at PICT. This blog is a small part of my story as a developer and the journey that eventually led to the creation of the Korus Java Framework.

How Everything Started​

Right after completing my 12th, I directly jumped into programming. I didn’t explore multiple languages—I started straight with Java, and that became my world.

The biggest influence behind my entry into programming was my cousins. They guided me, motivated me, and pushed me toward Java when I didn’t even fully understand what programming actually was.

Looking back, choosing Java as my first language was one of the best decisions I’ve ever made.

Growing with Java​

As I got deeper into the language, I began to explore:

• Modern Java frameworks
• Real-world projects
• End-to-end development
• Deployment pipelines

I still remember the moment when I built and deployed a complete project using a modern framework—that’s when I felt truly confident. That’s when I realized:

"Yes, I can build real engineering systems."

Since then, I’ve built over 50+ public GitHub repositories, constantly improving my skills and learning everything from the ground up.

Why I Created Korus​

India has a massive developer ecosystem, especially around Java, but one thing always felt missing:

We didn’t have our own Java framework.

That thought stayed with me. And one day, I decided:

"If something doesn’t exist, I will build it myself."

That’s how Korus started.

Korus is my attempt to bring something fresh, fast, and developer-friendly to the Java world, built with a strong vision and the belief that Indian developers can create world-class open-source tools.

Vision for the Future​

My dream is simple:

In the next 5 years, Korus should become one of the top Java frameworks in the world.

Not just another project—but something developers love, trust, and use confidently.

This is just the beginning.

Final Words​

If you're reading this:

• Start early
• Learn consistently
• Build fearlessly

You don’t need a perfect background or perfect conditions. You just need passion, discipline, and the courage to start.

Thank you for reading. This journey has shaped me as a developer, and Korus is the biggest step of that journey. The best part is still ahead.

Let’s compare the most popular modern Java frameworks.

Startup Time Comparison​

Dependency Injection Model​

Architecture Differences​

Spring Boot​

• Heavy runtime logic
• Massive ecosystem
• Easiest to use

Micronaut​

• Build-time friendly
• Faster than Spring
• Requires extra modules

Quarkus​

• GraalVM optimized
• Build-time profiling
• Complex stack

Korus​

• Simpler than Micronaut/Quarkus
• Faster than all of them
• Pure compile-time graph
• Clean Undertow runtime

When to choose which?​

Final Verdict​

Korus is ideal when you want:

• Fast startup
• Low memory usage
• Deterministic DI
• Zero reflection runtime

Korus stands as a next-generation framework built for modern Java workloads.

Most Java frameworks use runtime DI, where objects are created and wired when the application starts.
This works — but it's slow, unpredictable, and memory-heavy.

Korus takes a different approach:

All dependency injection is generated at compile time.

No reflection.
No proxies.
No classpath scanning.

Why Build-Time DI?​

Build-time DI solves three major problems:

Slow Startup​

Runtime DI frameworks scan the classpath and perform reflection when the app boots.

Korus eliminates this entirely.

Hidden Runtime Errors​

Many DI issues (circular dependencies, missing beans) are discovered only when you run the app.

Korus validates the entire DI graph at compile time.

Large Memory Footprint​

Reflection metadata, runtime registries, proxies — all reduce performance.

Korus generates pure Java code instead.

How Korus Generates the DI Graph​

During compilation, the Korus processor:

1. Scans your source code
2. Builds an internal DI model
3. Sorts beans with a topological algorithm
4. Generates:
   • Constructor injection code
   • Method injection code
   • Singleton registries
   • Route metadata
   • A full KorusMain bootstrap class

Everything is resolved before your application even runs.

Example Generated Code (Simplified)​

public final class UserService$$KorusBean {
    private final UserRepository repo;

    public UserService$$KorusBean(UserRepository repo) {
        this.repo = repo;
    }

    public UserService get() {
        return new UserService(repo);
    }
}

Build-Time Dependency Injection for Ultra-Fast Java Applications

Korus Framework is a modern Java framework designed around one core idea:

Move everything possible to compile time.​

Reflection, classpath scanning, proxies, and runtime bean creation all slow down traditional Java frameworks. Korus eliminates all of them by generating:

• Dependency wiring
• DI registries
• Routing metadata
• Bootstrapping code

during compilation, not at runtime.

The result:

• 120–250 ms startup time
• ~50 MB memory footprint
• Zero reflection
• Deterministic, safe DI graph
• Lightweight Undertow runtime

Why I Built Korus​

While working with Spring Boot and Micronaut, I noticed a common issue:

Even build-time DI frameworks keep some runtime magic.

Some still rely on reflection, some use proxies, some still scan packages.
This inspired the architecture of Korus:

• Pure annotation processing
• Pure compile-time registry generation
• No runtime analysis
• No surprises

Korus aims to bring:

• The developer experience of Spring
• The performance of Quarkus/Micronaut
• And a clean, minimal runtime

Architecture Overview​

Korus consists of two independent modules:

1. Korus Processor (Build-Time Engine)​

Responsible for:

• Scanning source code
• Building the DI graph
• Performing Jandex indexing
• Generating wiring and route registries
• Auto-generating KorusMain

2. Korus Framework (Runtime Engine)​

A lightweight Undertow-based runtime that:

• Loads pre-generated classes instantly
• Does not use reflection
• Does not scan the classpath
• Boots in under 0.25 seconds

Where We Are Today​

• 20,000+ lines of Java code
• Two-module architecture
• Stable build-time DI engine
• Fast Jandex-based lookup
• Hibernate + HikariCP integration

What’s Next?​

• Multi-module architecture (Core, Web, Data)
• Korus CLI (“korus new app”)
• Simpler configuration API
• New Data access module
• Build-time validation improvements

Korus is now open to the Java community.
I built it to solve real problems, and I’m excited to see what developers create with it.

👉 GitHub: https://github.com/korus-projects/