DEV Community: Surya Sourav

Free-Tech : Self-Hosted Tech Blog Platform

Surya Sourav — Sat, 25 Jul 2026 18:39:42 +0000

Recently i was very eager to write blogs - obv there are platforms like dev.to , medium but i wanted something of my own , like portfolio & a blog platform which would apparently make me look like a cracked engineer xD which am definitely trying to be by learning everyday...

coming to the topic , i wanted a swiss-knife platform that had every features a robust blogging platform would contain - Editor , Admin , upload Photos without managing CDNs of own , not worrying about Infra but relying on Free infrastructure provided by generous cloud platforms ( ex : Render )

Introducing Aurora :

Now there are many Blogging platforms in the world , why did i chose to build one myself ?

Imposter Syndrome ( wanted something of my own )
Customized Feature set that i wanted to exist in a Technical Blogging Platform / Dashboard

Coming to the Features :
there are a tonnes of feature the app has got included , you would absolutely love with the admin panel that helps you manage ur blogs , portfolio etc...

It would be better if you just use the platform rather than reading my 2-page long post on why its better ...
you would like it fs , just give it a try :D

Exclusive Note : its can be easily deployed over Render with 2-3 Clicks , read Readme.md !

Surya-sourav / Aurora

Self-hostable feature riched portfolio and technical blog platform.

Aurora : A Robust swiss-knife App for Technical Blogging

A self-hostable portfolio and technical blog platform.

Aurora ships an editor-first blog, a portfolio page, a career timeline, notes, bookmarks, and an admin dashboard — as a single Docker Compose stack. Deploy it to Render with one click, point it at a Postgres database, and start writing.

$ ls ~/
blog/  notes/  career/  bookmarks/  interests/  uses/  now/

Features

Content

Blog posts with markdown, syntax highlighting, callouts (> [!note]), KaTeX math, Mermaid diagrams, and wikilinks ([[slug]])
Categories to group posts (tech · finance · philosophy · …)
Series for multi-part write-ups, with prev/next navigation baked into each post
Short-form notes / TILs
Bookmarks with commentary
Career timeline with company logos
Portfolio page with a photo gallery
Editable /uses and /now pages

Reader experience

Auto-generated table of contents, reading progress bar, view counts
Related-post suggestions, social share buttons, Mastodon-based…

View on GitHub

Demo :

Custom Feature Options :

Admin Panel :

Portfolio :

-- A cool terminal to navigate ;D

Blogs come empowered with share functionality

More features are riched and updates would roll-out on custom requests.

DNS Resolution 101

Surya Sourav — Mon, 20 Jul 2026 17:53:53 +0000

'www.google.com → 142.250.183.4(the IP varies based on the edge server nearest to you)

Just a few keystrokes — but what really happens underneath?

Today I was digging down the rabbit hole of DNS resolution and found an interesting fundamental. Multiple sequential steps run to resolve a domain name and fetch its IP:

Domain name → Browser cache lookup → OS cache lookup → ISP's recursive resolver cache lookup (if all miss)

Here comes the actual recursive resolution:

i) Recursive resolver → asks the Root servers for the TLD server IPs (13 root identities, replicated into 1,700+ servers worldwide via anycast; their IPs are hardcoded in the resolver's root hints file)

ii) Resolver → fetches the authoritative server IPs from the TLD servers (.in, .com registries like NIXI and Verisign)

iii) Authoritative server responds with the real IP of the domain.

Note: The answer gets cached on the way back at each consumer level — resolver, OS, and browser — each honoring a TTL that the domain owner sets in the authoritative records.

Claude Code CLI Source Code

Surya Sourav — Tue, 31 Mar 2026 16:32:18 +0000

Just for educational Purpose , i am sharing the backup Source code of Claude-Code along with documentation :

Surya-sourav / xlaude-xode

Xlaude Xode — Leaked Source (2026-03-31)

On March 31, 2026, the full source code of Anthropic's Claude Code CLI was leaked via a .map file exposed in their npm registry.

How It Leaked

Chaofan Shou (@Fried_rice) discovered the leak and posted it publicly:

"Claude code source code has been leaked via a map file in their npm registry!"

— @Fried_rice, March 31, 2026

The source map file in the published npm package contained a reference to the full, unobfuscated TypeScript source, which was downloadable as a zip archive from Anthropic's R2 storage bucket.

Overview

Claude Code is Anthropic's official CLI tool that lets you interact with Claude directly from the terminal to perform software engineering tasks — editing files, running commands, searching codebases, managing git workflows, and more.

This repository contains the leaked src/ directory.

Leaked on: 2026-03-31
Language: TypeScript
Runtime: Bun
Terminal UI: React +…

View on GitHub

Built a CLI that gives your codebase a memory

Surya Sourav — Sun, 22 Mar 2026 08:31:06 +0000

Two weeks ago I was debugging a module I had written myself.
Sat staring at it for twenty minutes. everything was unfamiliar. The structure made no sense to me. I had to reverse-engineer my own code like a stranger had written it.
The uncomfortable truth — an AI had written significant chunks of it, I had reviewed, merged, and completely moved on. Two weeks later it was an alien to me !

I kept thinking about this. We talk constantly about LLMs having a context window like it is some fundamental technical limitation. We never apply the same framing to ourselves.

Developers have a context window too. AI-assisted development is just filling it faster than any human brain can track.

The problem with existing solutions
The obvious answer is "write better documentation." Every team says this. No team actually does it consistently — not because developers are lazy but because documentation written as a separate task from coding immediately starts drifting from reality.
Asking your IDE to document as it goes is worse. Cursor adds a new README for every three lines it touches. Imagine 3-4 Readme files just for an Auth module ! nobody on earth would feel enthusiastic to open ai generated docs !

What I actually needed was something that treated documentation as a continuous output of development — written automatically at the one moment developers never skip.
The commit. ( ~ Version Controlled Documentation )

What I built

DevMem is an open source Go CLI that hooks into your git workflow and maintains a living knowledge base inside your repository.

First run — crawls your entire repo and documents everything devmem init After every commit — patches only what changed devmem capture Ask your codebase anything devmem query "how does the auth module work?"

The thing I did not expect

The .devmem/ folder ends up being genuinely useful context for AI coding tools.
When Cursor or Copilot has access to accurate, current, structured documentation of every module — what it does, what its API surface is, what it depends on, what changed recently — it becomes meaningfully better at helping you. It stops making assumptions about your architecture because it is reading your actual architecture.
One knowledge base. Useful for your teammates and your AI tools simultaneously. That was not the original goal but it might be the most valuable outcome.

_
Honest rough edges_
Module detection uses directory heuristics. It works well on standard Go, Node, and Python project layouts. Unconventional structures need a small manual config to define module boundaries explicitly — the heuristics will miss or misgroup things.
Large messy refactor commits that touch many modules simultaneously stress-test the capture prompt in ways I have not fully solved. The classification is harder and the patches are less surgical than I want them to be.
The query command is only as good as your documentation is — which is only as good as your captures are. If you skip captures for two weeks the query answers drift.

_Stack
_
Go + Cobra
Anthropic API (Claude)
Single binary — no runtime dependencies
go install, direct download
MIT licensed

GitHub: https://github.com/surya-sourav/devmem

https://fun-tomato-aiuks1hrge.edgeone.app/

Demo :

Built this because I was tired of being a stranger in my own codebase. Curious whether anyone else has felt the same way and what approaches you have tried.
Brutal feedback welcome — especially on the module detection and the query command. Those are the two places where real-world codebases will stress-test the assumptions hardest.