DEV Community: Aniket Raj

The beginning

Aniket Raj — Tue, 07 Apr 2026 14:49:57 +0000

Most distributed systems don’t fail because of bad code.

They fail because of orchestration.

Not immediately. Not loudly.

Slowly.

A retry happens at the wrong time.
Two controllers race each other.
State drifts just enough to cause inconsistency.
And suddenly… debugging becomes guesswork.

You try again.

This time it works.

But you don’t know why.

We’ve built incredible systems.

But the way we program control planes is still:

• timing-dependent
• hard to reproduce
• difficult to reason about

I’ve been exploring a different question:

What if orchestration itself was deterministic?

What if:

Same input → same execution → same outcome

Every time.

That’s what I’ve been building.

A programming model where systems don’t just run.
They continuously stabilize toward a desired state.

Not scripts.
Not controllers.

Something else.

Still early. But the ideas are starting to take shape.

Sharing more soon.

distributedSystems #systemsdesign #programminglanguages #backend #cloudnative

Stop Alt-Tabbing to Check Metrics: Meet Vitals for VS Code 🚀

Aniket Raj — Fri, 26 Dec 2025 10:01:41 +0000

The Problem: Context Switching
As developers, we live in our IDE. But when we need to check how our app is performing—CPU usage, memory leaks, or HTTP latency—we have to alt-tab away to a browser, log into Grafana or Prometheus, and hunt for the right dashboard. It breaks our flow.

The Solution: Vitals
I built Vitals to bridge this gap. Vitals is an open-source VS Code extension that brings real-time observability directly into your editor.

It connects cleanly to Prometheus to visualize critical system and specific application metrics without you ever leaving your code.

✨ Key Features

Real-Time Metrics 📊 Visualize critical metrics with auto-updating, interactive charts.

CPU & Memory: Track resource usage trends instantly.
Request Latency: Monitor p50, p95, and p99 response times.
Custom Metrics: Support for any Prometheus metric you care about.

Live Log Stream 📜 Forget tail -f. Vitals gives you a terminal-like log viewer right in the dashboard with:

Syntax Highlighting: Color-coded for INFO, WARN, ERROR.
Search & Filter: Quickly isolate the logs you need.

Zero Configuration ⚡ If you have Prometheus running locally (e.g., via Docker or Homebrew), Vitals auto-discovers it. No complex JSON config required to get started—just install and view.

🛠️ Quick Start
Install the Extension: Search for "Vitals" in the VS Code Marketplace.
Run Prometheus: Ensure Prometheus is running (default port :9090).
Open Dashboard: Press Ctrl+Shift+P -> Vitals: Open Dashboard.
That's it! You should see your metrics streaming immediately.

🔮 What's Next?
We are actively working on v0.3.0, which will include:

Multi-datasource support (Datadog, AWS CloudWatch).
AI-powered anomaly detection.
Historical data analysis.
Try it out!
We’re open source and love feedback.

Download: VS Code Marketplace
Open VSX: Vitals
Source Code: GitHub (Give us a star! ⭐)
Docs: Get Started
Happy Coding! 💻

Introducing SCAN - A Must Have Plugin

Aniket Raj — Tue, 19 Aug 2025 11:05:40 +0000

🚨 LAUNCH ALERT: Introducing SCAN - The Gradle Plugin That Could Save Your Company from the Next Big Security Breach 🚨

I'm thrilled to announce the launch of SCAN (Sensitive Code Analyzer for Nerds) - a powerful Gradle plugin that automatically detects secrets, API keys, and sensitive information before they hit your codebase.

Why SCAN? Because one leaked API key can cost millions.

We've all seen the headlines: major companies exposing AWS credentials, database passwords, and API keys in public repositories. What if I told you there's now a way to catch these before they ever leave your development environment?

What makes SCAN different:

🔍 Multi-Layered Detection Engine
• Pattern recognition for 50+ secret types (AWS, GitHub, database credentials)
• Entropy analysis to catch encoded/obfuscated secrets
• Context-aware intelligence that understands when something looks like a secret but isn't

⚡ Built for Performance
• Parallel processing optimized for large codebases
• Memory-efficient streaming for massive files
• Incremental scanning for CI/CD pipelines

🛠️ Developer-First Design
• Zero configuration required - works out of the box
• Gradle-native integration with your existing workflow
• Multiple report formats (console, JSON, HTML)

Perfect for:
✅ Startups wanting enterprise-grade security
✅ Enterprise teams managing complex codebases
✅ DevOps engineers integrating security into CI/CD
✅ Security teams needing automated secret detection

The Numbers:
📊 Detects 50+ types of secrets
🚀 Scans 1000+ files in seconds
🔧 Integrates with GitHub Actions, Jenkins, GitLab CI
🏗️ Built with Kotlin for JVM ecosystem

This isn't just another security tool - it's your first line of defense against the kind of mistakes that make front-page news.

Get Started:
📖 Documentation: DOCS ↗
💻 Source Code: REPO ↗

Want to contribute?

This is an open-source project, and we're looking for contributors to help us:
• Add detection patterns for new secret types
• Improve performance optimizations
• Enhance CI/CD integrations
• Write documentation and examples

Whether you're a security engineer, DevOps specialist, or Kotlin developer, there's a place for your expertise in making the JVM ecosystem more secure.

Try it today - your future self (and your security team) will thank you when that critical API key gets caught before production instead of after it's leaked.

cybersecurity #devsecops #gradle #kotlin #appsec #security #opensource #java #kotlin #devtools #cicd #github #aws #secretsmanagement #infosec

P.S. If you've ever had that sinking feeling when you realized you committed something sensitive - you know exactly why SCAN exists. Let's make sure it never happens again.

Ready to secure your code? Drop a ⚡ in the comments if you're going to try SCAN, or share your own horror stories about leaked credentials (anonymously, of course! 😅)

AR.

Project KARL

Aniket Raj — Mon, 18 Aug 2025 09:03:27 +0000

Introduction: The Problem with Personalization

In the modern software landscape, AI-driven personalization is a key differentiator. From suggesting the next action in a developer tool to tailoring a news feed, intelligent features enhance user engagement. However, this intelligence often comes at a steep price: user privacy. The conventional approach requires aggregating vast amounts of user interaction data on centralized cloud servers, creating significant privacy risks, latency issues, and a dependency on network connectivity.

This trade-off inspired a question: Can we build a system that provides deep, adaptive personalization while guaranteeing that a user's data never leaves their device?

Project KARL (Kotlin Adaptive Reasoning Learner) is my answer to that question. It is an open-source, on-device AI framework designed from the ground up to be privacy-first, modular, and deeply integrated with the modern Kotlin ecosystem.

Here it is in action:

Explore Project KARL:

➡️ KARL-AI ↗

Core Philosophy & Vision

The vision for KARL is to empower developers to embed trustworthy AI directly into their applications. This is built on three foundational pillars:

Privacy by Design (Local-First): All learning, data processing, and state storage occur exclusively on the user's device. There is no data egress by default, eliminating the privacy concerns of cloud-based AI.
True Personalization (Adaptive Learning): KARL models start as a "blank slate" for each user. They learn and adapt incrementally from an individual's specific interactions, creating a uniquely tailored experience rather than applying a generalized, pre-trained model.
Developer-Friendly Modularity: The framework is architected as a set of decoupled modules with clear interfaces, allowing developers to plug in different machine learning backends, storage mechanisms, and UI components.

Technical Architecture: The Composable Container Model

To achieve these goals, I designed a multi-module Kotlin Multiplatform (KMP) architecture centered around the KarlContainer.

The KarlContainer is an isolated, stateful sandbox for each user's AI instance. It orchestrates the interactions between three key pluggable components defined in the :karl-core module:

LearningEngine (The Brain): An interface for the machine learning model. It defines the contract for incremental training (trainStep) and inference (predict). The initial reference implementation, :karl-kldl, uses the KotlinDL library to build and manage a simple Multi-Layer Perceptron (MLP) that adapts in real-time.
DataStorage (The Memory): An interface for local persistence. It's responsible for saving and loading the KarlContainerState (the serialized model weights and metadata). The reference implementation, :karl-room, leverages AndroidX Room's KMP support with a SQLite backend, using KSP for compile-time code generation.
DataSource (The Senses): An interface implemented by the host application. It acts as the bridge, observing user actions, transforming them into anonymized InteractionData objects, and feeding them into the container.

This decoupled design ensures that the core orchestration logic remains independent of the specific ML library or database used, making the system highly extensible.

Key Technical Challenges & Solutions

Building an on-device AI framework, especially in the Kotlin ecosystem, presented several interesting challenges:

1. On-Device Incremental Learning:

Challenge: How do you train a model effectively with a stream of single data points without the massive computational resources of the cloud?
Solution: I implemented a trainStep function in the KLDLLearningEngine that performs a single, low-latency training pass on the model with each new InteractionData point. This "online learning" approach allows the model to adapt continuously. State is managed using a Mutex to ensure thread-safe updates to the model during concurrent training and prediction requests.

2. State Persistence and Management:

Challenge: How do you save and restore the entire learned state of a neural network efficiently on a local device?
Solution: The getCurrentState() method in the LearningEngine serializes the model's weights and key metadata (like the number of interactions processed) into a ByteArray. The RoomDataStorage implementation then persists this binary blob in a local SQLite database. On initialization, this state is loaded back, allowing the AI to resume its learned state across application sessions.

3. Reactive UI Integration:

Challenge: How do you display the AI's real-time status and predictions in a modern, declarative UI without blocking the main thread?
Solution: The :karl-example-desktop application was built using Jetpack Compose for Desktop. I used Kotlin Coroutines and StateFlow extensively. The application's ViewModel observes the KarlContainer and exposes its state (predictions, interaction count, confidence trends) as reactive streams. The Compose UI then subscribes to these flows using collectAsState(), ensuring that the dashboard updates automatically and efficiently whenever the underlying AI state changes.

4. Build System Complexity (Gradle & KMP):

Challenge: Managing a multi-module Kotlin Multiplatform project with complex dependencies like KSP, Compose, and KotlinDL is non-trivial and prone to configuration errors.
Solution: I implemented a Gradle Version Catalog (libs.versions.toml) as the single source of truth for all plugin and library versions. This drastically improved build script readability, maintainability, and resolved numerous dependency conflicts. I also set up a full CI/CD pipeline using GitHub Actions to automatically build, test (with ktlint), and deploy the Dokka documentation, ensuring a high standard of quality and automation.

The Result: A Demonstrable Prototype

The culmination of this work is a polished, fully functional diagnostic dashboard that showcases KARL in action. It allows a user to simulate actions, and in real-time, observe:

The AI Insights panel, showing the model's status, the number of interactions processed, and a live-updating "Confidence Trend" sparkline.
The Prediction Details panel, displaying the input context, the primary prediction with its confidence score, and alternative suggestions.

Future Directions & Personal Learnings

This project has been an incredible learning experience in software architecture, on-device machine learning, and modern Kotlin development. While the foundation is solid, the roadmap for KARL is exciting:

Advanced Models: Implementing more sophisticated LearningEngines using RNNs or Transformers to better capture sequential patterns.
Robust Serialization: Moving from a basic DataOutputStream to a more structured format like Protocol Buffers or JSON for model state persistence.
Broader KMP Support: Extending the core functionalities and providing reference implementations for Android and iOS.

Project KARL demonstrates that it is feasible to build intelligent, adaptive systems that respect user privacy by design. It represents my passion for tackling complex architectural challenges and my commitment to building high-quality, well-documented, and forward-thinking software.

Project KARL AI

Aniket Raj — Fri, 08 Aug 2025 14:34:21 +0000

Aniket Raj

Aug 6 '25

It's Alive! Project KARL is Now Open Source.

#showdev #kotlin #ai #opensource

Comments

3 min read

It's Alive! Project KARL is Now Open Source.

Aniket Raj — Wed, 06 Aug 2025 07:11:08 +0000

Hey Dev Community!

It’s here.

After months of late-night coding sessions, wrestling with Gradle, architecting APIs, and sharing the journey with all of you, I'm incredibly proud and excited to announce that Project KARL (Kotlin Adaptive Reasoning Learner) is now officially open source!

The repository is public, the code is available, and the first alpha version is ready for you to explore.

Check out Project KARL on GitHub! ↗

A Quick Recap: What is KARL?

For those new to the journey, KARL is my answer to a question that drove this entire project: Can we build powerful, personalized AI without sacrificing user privacy?

KARL is an open-source library, built entirely in Kotlin, for creating on-device, adaptive AI models.

Privacy-First: All learning and data storage happen locally. No cloud servers, no data egress.
Truly Personal: The AI starts as a blank slate and learns exclusively from an individual user's interactions, creating a deeply personalized experience.
Modular & KMP-Powered: Built on a clean, container-based architecture with a Kotlin Multiplatform core, making it flexible and extensible.

From "Build Hell" to a Working Demo

The path to this release was a marathon. I've shared some of the struggles with dependency resolution and build configurations right here on dev.to. But today, I'm thrilled to share the result: a fully functional example application that brings the entire KARL ecosystem to life.

Here it is in action:

What you're seeing is the complete, end-to-end data flow:

A user action is simulated in the Controls panel.
The DataSource sends this interaction to the KarlContainer.
The KLDLLearningEngine performs a trainStep, updating its local model.
The AI Insights panel updates in real-time, showing the Interactions Processed count and the Confidence Trend.
A new prediction is requested, and the Prediction Details panel displays the model's output, including its confidence and alternatives.

All of this happens instantly, on-device, with a persistent state managed by our Room-based DataStorage implementation.

What's in the Box? (The Modules)

The initial release includes:

:karl-core: The KMP core with all the essential interfaces and data models.
:karl-kldl: A LearningEngine implementation using KotlinDL.
:karl-room: A DataStorage implementation using AndroidX Room and KSP.
:karl-compose-ui: Reusable Jetpack Compose components.
:karl-example-desktop: The fully runnable diagnostic dashboard you see in the GIF!

This is Just the Beginning: An Invitation to Contribute

This is an alpha release. The foundation is laid, but there is so much more to build. I'm officially inviting you to be a part of this journey.

Explore the Code: Dive into the repository. I'd love to hear your feedback on the architecture.
Run the Example App: Clone the repo and run the desktop app yourself!
Read the Docs: The Official Documentation is live with detailed guides.
Contribute: Check out the CONTRIBUTING.md and the open issues. Whether you're a Gradle expert, an ML enthusiast, or a Compose wizard, there's a place for you. I'll be adding good first issue labels soon!

Thank you to everyone who has followed along, offered encouragement, and shown interest. This project was born out of a belief in a different kind of AI, and I can't wait to see where we, as a community, take it next.

Let me know what you think in the comments!

RELEASING KARL DOCS

Aniket Raj — Sat, 02 Aug 2025 11:57:06 +0000

Hello, Dev Community!

For the past couple of months, I've been on an incredible journey building something I'm truly passionate about. Today, I'm thrilled to take the first major step in sharing it with all of you.

I'm talking about Project KARL (Kotlin Adaptive Reasoning Learner).

What is KARL?
At its heart, KARL is an answer to a question that has been on my mind: Can we build powerful, personalized AI without sacrificing user privacy?

Project KARL is an open-source library, built entirely in Kotlin, designed to create on-device, adaptive AI models. Instead of sending your data to the cloud to be processed, KARL learns and adapts exclusively on the user's device. It starts as a blank slate and becomes uniquely tailored to an individual's behavior over time.

It's built on a few core principles:
• Privacy-First: All learning and data storage are local by default.
• Truly Personal: The AI adapts to one user, not a generalized population.
• Modular & Composable: Designed with a clean, container-based architecture to be easily integrated into modern Kotlin applications.

Action is Always Preceded by Learning

In the spirit of that motto, I'm taking a docs-first approach to this release. I believe that for a project with a new architectural pattern to be truly understood and adopted, the concepts and guidelines must be clear from day one.

Before you dive into the code, I want you to have the complete map.

Today, I am officially releasing the complete documentation for Project KARL.

This includes everything from high-level introductions and core concepts to detailed integration guides, API overviews, and contributor information. It’s the blueprint for the entire project.

→ Explore the Official KARL Documentation Here: KARL DOCS ↗

Mark Your Calendars: The Code is Coming

With the documentation now public, you can learn, explore, and understand the vision. The next step is action.

The official open-source repository for Project KARL will be made public soon.

On that day, you'll have access to the full source code for all the core modules, implementations, and the example desktop application that brings it all to life.

What to Expect

The initial release will be an alpha version, a solid foundation ready for feedback, experimentation, and community contribution. It's the start of a journey, and I'm incredibly excited to build it in the open with all of you.

So, take some time to read through the docs. Understand the "why" and the "how." And get ready to dive into the code.
I can't wait to share it with you.
We're on the edge.
Get Ready.

Building AI Model

Aniket Raj — Sat, 10 May 2025 19:03:26 +0000

Hello Readers

It's day #14 of building an AI - Model.

Explore more here