DEV Community: Abhiram

We Built a Signal Protocol Messenger. Then We Checked If It Was Legal in 5 Jurisdictions.

Abhiram — Sat, 25 Jul 2026 18:08:15 +0000

TL;DR: We checked Halonyx — our self-hosted E2EE messenger implementing X3DH + Double Ratchet — against the EU's Chat Control, US EARN IT Act, India's IT Rules 2021, the UK's Online Safety Act + Investigatory Powers Act, and the UN Cybercrime Convention. Here's the honest answer for each.

When you implement end-to-end encryption from scratch, you spend a lot of time thinking about cryptographic threat models. Key substitution attacks. OPK exhaustion. WebRTC IP leakage. The adversaries you model are largely technical.

At some point, you have to model a different kind of adversary: the legal one.

We built Halonyx — a self-hostable E2EE messenger implementing the Signal Protocol (X3DH key exchange, Double Ratchet, Safety Numbers, WebTorrent P2P file transfer). The server architecturally cannot read your messages — not by policy, but because it holds no decryption keys and no plaintext. We wrote a STRIDE threat model across 17 attack surfaces.

We did not write a legal threat model. So we did.

This is what we found across five jurisdictions. None of this is legal advice. All of it is current as of July 2026, in a policy landscape that is actively moving.

Quick Architecture Recap

Before the jurisdiction breakdown, a one-paragraph recap of what Halonyx actually does, because the architecture is what determines the legal exposure.

The relay server stores and forwards only AES-256-GCM ciphertext. It holds no private keys, performs no cryptographic operations on behalf of users, and has no mechanism to identify message content or originators. User identity is a pseudonymous 256-bit USID — the server stores only SHA-256(USID). Files transfer peer-to-peer via WebTorrent; the server receives only a magnet URI.

This architecture — which we call Federated Relay Architecture (FRA) — is what creates the legal situation described below.

1. European Union — Chat Control / CSAR

Current status: No conflict with anything currently in force.

The EU's Child Sexual Abuse Regulation (CSAR), known as "Chat Control," has been in negotiation since 2022 and has generated more alarming headlines than almost any other encryption policy debate.

The current actual situation as of mid-2026:

The original mandatory client-side scanning demand was dropped by the Council in late 2025
A temporary voluntary-scanning derogation expired April 2026; a July 2026 extension vote survived but with an amendment explicitly excluding E2EE communications from its scope
The permanent regulation is still in trilogue negotiation — open questions remain on age verification and "risk-mitigation" design obligations Halonyx position:

No conflict with anything currently in force. We have no scanning mechanism — there is nothing to exclude, because the server never accesses plaintext. Age verification is an open gap if it becomes a firm legal requirement; we do not implement it. The permanent regulation's "risk-mitigation" obligations are not yet defined clearly enough to assess against.

The EU is trending away from mandatory scanning of E2EE services, not toward it, as of this writing.

2. United States — EARN IT Act + PQC Executive Order

Current status: No enacted law. Two tracks pulling in opposite directions.

Two separate policy threads run in parallel in the US and almost never get discussed together:

EARN IT Act (not enacted as of mid-2026): Would condition Section 230 liability protection on compliance with "best practices" set by a government-influenced commission. Critics including EFF, ACLU, and cryptographer Matthew Green argue this creates indirect pressure toward backdoors or scanning without explicitly mandating either. It has not passed in multiple Congressional sessions.

2026 PQC Executive Order (enacted): Directs federal agencies and contractors to complete a transition to post-quantum cryptography by December 31, 2030. NIST, NSA, and CISA are leading standards work. This is a cryptographic strengthening mandate — the opposite direction from EARN IT.

Halonyx position:

No current compliance obligation. The PQC gap is real — we use classical curves (X25519, P-256, Ed25519), the same as Signal's current production design. CRYSTALS-Dilithium and Kyber integration is on our roadmap. The 2030 deadline applies to federal contractors, not to us at current stage.

The important framing: the largest federal cryptographic initiative currently running in the US points toward stronger encryption, not backdoored encryption. The coverage of the US encryption landscape that focuses only on EARN IT misses this.

3. India — IT Rules 2021, Rule 4(2) Traceability

Current status: In force, litigated, and in direct structural tension with strict E2EE.

This is the only jurisdiction in this survey where there is a currently-in-force legal rule in genuine conflict with how Halonyx works.

IT Rules 2021, Rule 4(2) requires "significant social media intermediaries" (5M+ users) offering messaging to identify the "first originator" of a message within India upon a valid judicial or law enforcement order for specified serious offences.

WhatsApp challenged this in the Delhi High Court, arguing traceability is technically impossible without retaining data that breaks E2EE guarantees. Signal's founder has publicly stated the two are architecturally incompatible. The government's FAQ insists the intent is not to break encryption while declining to specify a technical implementation that wouldn't. The litigation remains unresolved.

Halonyx position:

Technically not applicable at current scale — we are nowhere near 5 million users. But architecturally, Halonyx is on the same side of this argument as WhatsApp and Signal, for the same structural reason: a server holding only SHA-256(USID) and AES-256-GCM ciphertext has no mechanism to identify a message originator even if legally compelled. The architecture produces the same "traceability is architecturally impossible" conclusion independently of our intent.

This is the jurisdiction to watch most carefully if Halonyx ever scales.

4. United Kingdom — Online Safety Act 2023 + Investigatory Powers Act 2016

Current status: The clearest existing enforcement mechanism in this survey, already reportedly used once.

The UK runs two parallel legal mechanisms:

Online Safety Act 2023 (OSA): Empowers Ofcom to require "accredited technology" — including client-side scanning — on encrypted services. No accredited technology currently exists. Ofcom's final implementation guidance was expected in spring 2026; enforcement has not yet been technically deployed against any service.

Investigatory Powers Act 2016 (IPA): Allows the Home Secretary to issue secret Technical Capability Notices (TCNs) compelling companies to remove "electronic protection." This mechanism was reportedly used against Apple's iCloud Advanced Data Protection in 2025. Apple withdrew the feature for UK users rather than complying. The matter is before the Investigatory Powers Tribunal.

Signal has published that it would exit the UK market before implementing client-side scanning. This is not rhetorical — it is a statement about architectural limits.

Halonyx position:

Less likely to attract TCN-level attention than Apple, for obvious scale reasons. But not architecturally exempt. A legal order compelling a client-side change would bind Halonyx's maintainers the same way it bound Apple's — structural difficulty does not constitute a legal defence.

What the architecture does provide: the non-exportable CryptoKey design and server-side blindness mean silent server-side compliance is structurally impossible. Any compliance would require a visible, explicit change to the client codebase — which, for an open-source AGPL-3.0 project, would be publicly observable.

The OSA is the more concerning long-term mechanism because it applies to encrypted services broadly, not just major providers. The accredited technology question — what would even satisfy Ofcom's requirement — remains technically unresolved.

5. UN Convention Against Cybercrime

Current status: Not yet in force anywhere. Monitor, don't act yet.

The UN Convention against Cybercrime was adopted by the General Assembly in December 2024 and opened for signature in October 2025. It requires 40 ratifications to enter into force. As of mid-2026, 72+ countries have signed — but signature creates no binding obligations. The ratification count remains short of 40. The US has not signed. India has not signed.

Article 28.4 is the provision privacy organisations (EFF, Internet Society, Privacy International) are watching: it could be read to permit domestic authorities to compel handover of encryption keys or other information defeating security measures during search and seizure, with safeguards left to domestic law rather than specified in the treaty.

Halonyx position:

Not applicable anywhere currently. Even once in force, the treaty creates no direct obligations on services — it directs states to legislate domestically. The eventual effect flows through whichever of the four national regimes above choose to ratify and implement Article 28.4, not through the treaty text directly.

The Cross-Jurisdiction Picture

Jurisdiction    | Mandates breaking E2EE?  | Currently enforced?
----------------|--------------------------|--------------------
EU (CSAR)       | No (E2EE excluded)       | No
US (EARN IT)    | Not enacted              | No
India (IT Rules)| Effectively yes (argued) | Contested in court
UK (OSA + IPA)  | IPA: yes (Apple case)    | IPA: reportedly yes
                | OSA: power exists        | OSA: not yet
UN Convention   | Ambiguous                | Not in force

The Architectural Observation That Matters More Than the Jurisdiction Table

Every mechanism reviewed here — client-side scanning, traceability, TCNs, and the UN treaty's compelled-key-handover language — works by compelling change at the client or at the point of key exchange.

A server that holds no plaintext and no decryption keys cannot be secretly compelled to hand over content it does not possess. This is what Halonyx's Federated Relay Architecture produces: silent server-side compliance is structurally impossible, because there is nothing to silently comply with.

This is not a legal shield. A government order compelling a client-side change would still bind us. What the architecture guarantees is that such compliance could not happen silently — it would require a visible, explicit change to an open-source codebase that anyone can audit.

Transparency as an architectural property, not just a policy aspiration.

What We Are Watching

Three things we are tracking as they develop:

EU trilogue conclusion — the permanent CSAR regulation will define whether "risk-mitigation obligations" mean anything concrete for E2EE services. The current direction is encouraging but not settled.

India High Court ruling — the Delhi High Court decision on Rule 4(2) will either validate or reject the "traceability is architecturally incompatible with E2EE" argument at a judicial level. This will have implications beyond India.

UK OSA accredited technology — whether Ofcom ever identifies technology that satisfies the OSA scanning requirement without breaking E2EE. The cryptographic community's consensus is that no such technology exists. If Ofcom concludes the same, the OSA's bite on E2EE services diminishes significantly.

Conclusion

Halonyx is not in conflict with any currently-enforced law in the EU or US. It has no live compliance obligation in India or the UK today, primarily because its scale and non-commercial status place it outside the practical reach of existing mechanisms — not because its architecture has been tested against them at scale.

The global regulatory direction is not uniformly toward weaker encryption. The largest cryptographic initiative currently running in the US points toward stronger algorithms. The EU has, for now, excluded E2EE from scanning scope. The most aggressive enforced mechanism (UK IPA) has produced market exit rather than compliance from a major provider.

The picture is messier and more contested than either "encryption is under attack" or "encryption is safe" captures.

Full technical writeup on how Halonyx works:
I Built a Signal Protocol Messenger from Scratch

GitHub: github.com/ABHIRAM-CREATOR06/Halonyx (AGPL-3.0)

This article reflects public reporting as of July 2026. Not legal advice. The policy landscape is actively moving.

Halonyx, Part 2: Interactive Backend Simulator

Abhiram — Fri, 10 Jul 2026 13:13:29 +0000

A few weeks ago I published a post about building Halonyx which is a Signal Protocol messenger that I implemented from scratch with X3DH key exchange, Double Ratchet, Safety Numbers, and peer-to-peer file transfer via WebTorrent.

The response surprised me. Siyu, who is building agent-to-agent communication infrastructure, spotted that X3DH's "establish a session with someone who isn't present" property was exactly what they needed. Evans, who runs an anonymous Q&A app, asked why I chose X3DH over simpler approaches. Both conversations went deep into protocol design, which was genuinely useful.

But I also noticed something. Most people who clicked through were engineers who already knew what a Diffie-Hellman operation was. Everyone else that include my friends, classmates, faculty members and people who messaged me after seeing a WhatsApp status, read the README, hit the X3DH section, and left.

That gap bothered me. The whole point of publishing Halonyx was to be transparent about how it works, including where it falls short. A README that only engineers can follow is not really transparency.

So I built a simulator.

What it is

A single HTML file with no framework, no build step, no external dependencies that walks through the complete Halonyx protocol in 14 steps. It runs entirely in the browser.

Two modes, same steps:

Beginner mode uses plain English and consistent analogies. Bob's key bundle is a padlock on a public noticeboard. The Double Ratchet is a combination lock that changes its own combination after every use. Safety Numbers are two people reading out the same number over a phone call. The technical terms are introduced, explained in one sentence, and then used consistently.

Protocol mode shows the actual implementation — Halonyx API endpoints, SQLite schemas, WebSocket frame structures, real cryptographic parameters, code snippets from the source.

A toggle switches between them. Both modes share the same interactive elements and the same "show me the technical detail" expandable panel on every step.

What the 14 steps cover

The simulator does not skip the uncomfortable parts.

Key setup and OPK exhaustion. Bob uploads his X3DH key bundle — Identity Key, Signed Pre-Key, ten One-Time Pre-Keys. The simulator then immediately shows what happens when an attacker drains all ten OPKs on purpose. The session falls back from four DH operations to three. The forward secrecy guarantee weakens. Halonyx has a replenishment endpoint but no automatic client-side top-up yet — the simulator shows this gap explicitly, not buried in a footnote.

X3DH key exchange. All four DH operations, each labeled with what security property it provides. DH1 binds identities. DH2 and DH3 add ephemeral randomness. DH4 uses the consumed one-time key for deniability. The shared secret appears on Alice's side and Bob's side simultaneously — the server shown passing only an opaque packet between them.

Double Ratchet. A ratchet that visibly clicks forward with each message, each click producing a different key that disappears immediately after use. The "send message" button lets you click through several messages and watch the keys change. Forward secrecy and post-compromise security labeled as properties that become true as the ratchet advances.

The key substitution attack. This is step six of fourteen, which is earlier than most explainers put the attack. That is intentional. The simulator shows the attack before showing the defense — Mallory sliding in between Alice and the server, swapping Bob's public key with her own, reading everything, re-encrypting and forwarding so neither party notices. A red banner: "Server reading all messages. Neither party is aware." It is supposed to feel alarming.

Safety Numbers. The defense against step six. Both parties independently compute SHA-256 of their combined identity keys, formatted as sixty digits in twelve groups of five. They compare over a voice call. An "attack mode" toggle lets you watch the numbers diverge when Mallory is active, and snap back to matching when she is not.

Complete message flow. The full nine-step sequence from Alice hitting send to Bob reading the message, including the AES-256-GCM encryption, the WebSocket frame structure, the offline mailbox queue, and the delete-on-delivery guarantee. The server shown at every step receiving only an encrypted blob it cannot open.

WebTorrent file transfer. Files arc over the server entirely, bypassing it. The server receives only the magnet URI. The IP exposure via WebRTC STUN is shown as a labeled limitation with its mitigation — not hidden.

Triple database isolation. The three SQLite databases and the one-way SHA-256(USID) link that connects them. An attacker stealing app.db shown receiving only hashed identifiers and encrypted payloads.

USID identity. No phone number. No email required. A 256-bit random number as your identity, with only its hash stored server-side.

Why HTML, CSS, and JavaScript with no dependencies

A few reasons.

The obvious one is that anyone can open it, inspect every line, and verify it matches what the README claims. There is no compiled bundle to dig through.

The less obvious one is that it felt right for a transparency tool to be fully legible. Halonyx is trying to be a system where the security properties are verifiable, not just claimed. A simulator explaining it should work the same way.

The constraint also kept the scope honest. No framework means no component library, no routing, no build configuration — just the explanation itself.

The part I was most uncertain about

The OPK exhaustion step almost did not make it in.

It is a real limitation. Showing it means admitting that a specific attack on Halonyx produces a measurable weakening of the forward secrecy guarantee on a session. That is not comfortable to put in a public explainer.

But the dev.to comments on the first post convinced me. Vinicius Pereira's comment about the WebCrypto curve inconsistency that X25519 for X3DH alongside P-256 for identity keys is a forced trade-off rather than a mistake, because non-exportable CryptoKey objects were only reliably available for NIST curves until recently that was the most technically useful response I got. It came from being honest about limitations in the original post, not from presenting the project as finished.

The simulator takes the same approach. If you are going to explain how a security system works, the limitations are part of how it works.

Try it

The simulator is linked from the Halonyx README and runs directly in the browser.

GitHub: https://github.com/ABHIRAM-CREATOR06/Halonyx
Previous Post: https://tinyurl.com/28ru6uzm
Live demo:

If you find something the beginner explanation gets wrong, or a protocol detail in protocol mode that does not match the source, I want to know. The point is accuracy, not just accessibility.

I Built a Signal Protocol Messenger from Scratch with X3DH, Double Ratchet, Safety Numbers, P2P File Transfer

Abhiram — Mon, 29 Jun 2026 10:43:54 +0000

Most developers think TLS means secure. It doesn't.

TLS protects the transport. The server still decides whose
public key you encrypt to. A malicious server hands you its
own key, reads everything you send, re-encrypts it, and
forwards it along. Neither party notices.

This is the attack most "end-to-end encrypted" apps are
silently vulnerable to. We built Halonyx to close it.

🔗 GitHub · 🌐 Live Demo

Why Build Another Messenger?

Most "secure messenger" projects I've seen fall into one of two categories:

They use TLS and call it "encrypted" — which protects the transport, not the content from the server
They use a crypto library as a black box without understanding what's happening inside I wanted to actually implement the Signal Protocol from first principles: understand every DH operation in X3DH, trace how the Double Ratchet chains evolve, and design a system where the relay server is architecturally excluded from reading anything — not just by policy, but by cryptographic design.

This is Halonyx. Here's what we built and what we learned.

The Core Problem: Trust No Server

The typical E2EE claim is "only you and the recipient can read messages." But there's a hidden assumption: that the server gives you the real public key of your contact.

A malicious server can silently substitute its own key during the X3DH handshake. You encrypt to the server's key, it decrypts, re-encrypts to your contact, and neither party knows. This is a MITM attack at the key distribution layer.

Signal solves this with Safety Numbers. We implemented the same mechanism — more on that later.

Signal Protocol: What's Actually Happening

X3DH Key Exchange

X3DH (Extended Triple Diffie-Hellman) lets two parties establish a shared secret even if one of them is offline. It uses four DH operations:

DH1 = DH(IKa,  SPKb)   — Alice's identity key    × Bob's signed pre-key
DH2 = DH(EKa,  IKb)    — Alice's ephemeral key   × Bob's identity key
DH3 = DH(EKa,  SPKb)   — Alice's ephemeral key   × Bob's signed pre-key
DH4 = DH(EKa,  OPKb)   — Alice's ephemeral key   × Bob's one-time pre-key

SK  = HKDF(DH1 ‖ DH2 ‖ DH3 ‖ DH4)

Why four operations instead of one? Each adds a layer:

DH1 binds both parties' long-term identities
DH2 + DH3 add ephemeral randomness — even if Alice's long-term key is later compromised, past sessions are safe
DH4 uses a one-time pre-key (OPK) — once consumed, it's gone. Provides deniability and replay protection. The server stores Bob's pre-key bundle and relays Alice's x3dh_init packet. It never derives SK — it never has enough information to.

Double Ratchet

After X3DH establishes the root key, every message advances the Double Ratchet:

Symmetric ratchet: Each message derives a unique message key from the current chain key via HKDF. The chain key advances. Message keys are used once and discarded.

DH ratchet: Every time the conversation direction changes (reply), a new DH exchange runs. This derives fresh root and chain keys, "healing" the session even if a message key was previously compromised.

The result:

Forward secrecy — compromising key N reveals nothing about keys 1…N-1
Post-compromise security — after a breach, the DH ratchet step re-randomises the session ### Key Persistence: The Hard Part

WebCrypto's CryptoKey objects can be marked non-exportable — the raw key material is never accessible to JavaScript. We store these directly in IndexedDB.

// Keys never leave as raw bytes
const keyPair = await crypto.subtle.generateKey(
  { name: "ECDH", namedCurve: "P-256" },
  false, // non-exportable
  ["deriveKey", "deriveBits"]
);

Session state (root key, chain keys, ratchet DH keys, message counters) is serialised and persisted across page reloads. Each USID maps 1:1 to a stable cryptographic identity.

Safety Numbers: Closing the MITM Gap

Even with perfect E2EE, a malicious key server breaks everything. Safety Numbers are the solution.

Each user generates a P-256 ECDH identity key pair at registration. Both parties independently compute:

safetyNumber = SHA-256(
    sort_lex([
        SHA256(aliceUsid) + alicePubKey,
        SHA256(bobUsid)   + bobPubKey
    ])
)
// → 12 groups of 5 digits, 60 digits total

Lexicographic sorting ensures both parties derive an identical result regardless of who initiates. They compare the number out-of-band (voice call, in person). If they match — no MITM. If they differ — a key was substituted.

We also implement key change detection: the last-seen safety number is stored in localStorage. On every subsequent session, if the number changes, a prominent warning is shown before proceeding.

Without Safety Numbers (vulnerable):

  Alice                  Server (malicious)              Bob
    │── GET /public-key ──→│                               │
    │←─ Mallory's key ─────│  ← server substitutes        │
    │  encrypts to Mallory  │                               │
    │── ciphertext ────────→│── re-encrypts to Bob ────────→│

With Safety Numbers (protected):

  Alice sees:  12345 67890 11111
  Bob   sees:  72891 23456 78901   ← mismatch → attack caught ✅

P2P File Transfer via WebTorrent

Server involvement in file transfer is a massive privacy leak. Our solution: the server never touches files.

Sender seeds the file using WebTorrent — BitTorrent running in the browser via WebRTC data channels
A magnet URI is sent to the recipient through the encrypted message channel
Recipient's browser leeches directly from the sender
Public trackers handle peer discovery only — they never see file contents
STUN/TURN handles NAT traversal for users behind symmetric NATs

Sender Browser                    Recipient Browser
  └── WebTorrent.seed(file)
        └── magnet URI (via encrypted WS)  ──→
                                              WebTorrent.download()
              WebRTC DataChannel ────────────────────────────→
              (direct P2P, server not involved)

Live upload speed, download speed, progress, and seeding ratio are displayed in real time via WebTorrent's event API.

Database Architecture: Dual Isolation

Identity metadata and operational data live in separate SQLite databases, linked only by SHA-256(USID). Plaintext identity is never stored anywhere.

identity.db    →   name · email · hashed_usid
app.db         →   users · contacts · mailbox (hashed_usid only)
keys.db        →   X3DH public key bundles (hashed_usid only)

Even if app.db is fully compromised, an attacker gets hashed USIDs and encrypted message payloads — no names, no emails, no identity. The databases are only correlated by SHA-256(USID), which is a one-way mapping.

Offline Mailbox: At-Most-Once Delivery

When a recipient is offline, the server queues the encrypted payload. On their next WebSocket reconnect, all queued messages are flushed and immediately deleted:

Sender → Server (recipient offline)
  └── INSERT INTO mailbox (encrypted_payload)
  └── { type: "queued" }   ← sender sees clock icon

Recipient reconnects
  └── SELECT * FROM mailbox WHERE recipient = ?
  └── forward each message via WebSocket
  └── DELETE FROM mailbox WHERE recipient = ?

The server stores only the already-encrypted payload — it cannot read the content. Deletion on flush ensures no permanent retention.

Cryptographic Primitives Summary

Primitive	Algorithm	Key Size
Symmetric Encryption	AES-256-GCM	256 bits
Key Derivation	HKDF-SHA256	256 bits
Hashing	SHA-256	256 bits
Key Exchange	X25519 (ECDH)	256 bits
Identity / Safety Numbers	P-256 (ECDH)	256 bits
Message Authentication	HMAC-SHA256	256 bits
Pre-Key Signing	Ed25519	256 bits

Guarantees: forward secrecy · post-compromise security · HMAC authentication · deniability · pseudonymity · MITM detection

What We Got Wrong (and Fixed)

Curve inconsistency. Signal uses Curve25519 throughout. We used P-256 for identity keys because WebCrypto's ECDH is more consistent across browsers for that curve. The trade-off: P-256 is NIST-standardised (some distrust NIST curves post-Snowden). X25519 is used for X3DH key exchange where performance matters more.

OPK exhaustion. One-time pre-keys are consumed per session. If a user goes offline for a long time, their OPK supply can be exhausted. We added a /keys/replenish endpoint and OPK monitoring, but automatic client-side replenishment is on the roadmap.

WebRTC IP leaks. WebTorrent uses WebRTC, which can leak local and public IPs via STUN. Documented in our STRIDE threat model — mitigation requires a VPN or disabling WebRTC at the browser level.

Roadmap

[ ] Safety Number QR code scan
[ ] Post-quantum cryptography (CRYSTALS-Dilithium / SPHINCS+)
[ ] Multi-device session sync
[ ] Group messaging via Sender Keys
[ ] Voice & video (WebRTC)
[ ] Push notifications (Web Push / VAPID)

Try It / Contribute

🔗 GitHub: https://github.com/ABHIRAM-CREATOR06/Halonyx
🌐 Live: https://halonyx.onrender.com
📄 Threat Model: datathreat/datathreat.md — STRIDE analysis, 17 attack surfaces
📊 Benchmarks: benchmark/benchmark.md — X3DH, Double Ratchet, WebSocket, SQLite latencies

Self-host in three commands:

git clone https://github.com/ABHIRAM-CREATOR06/Halonyx.git
cd halonyx && npm install
npm start

Happy to discuss any of the protocol decisions in the comments — especially the curve choice, the safety number design, or the dual-database isolation model.

I Built a WCAG 2.2 Accessibility Checker and Shipped Its SDK to Three Package Registries as a CS Student published: true

Abhiram — Thu, 19 Mar 2026 18:45:59 +0000

I Built a WCAG 2.2 Accessibility Checker and Shipped Its SDK to Three Package Registries as a CS Student

Most of my college projects lived and died on a USB drive. This one ended up on NuGet, npm, and Cargo. Here's how it happened and what I learned.

The Problem

While working on a web project, I wanted to check if my site was accessible. Every tool I found was either a browser extension that was useless for CI, a paid SaaS, or a basic linter that didn't handle JavaScript-rendered content at all.

WCAG 2.2 had just introduced new criteria — target size minimums, redundant entry prevention — and nothing free was checking for those yet. So I built my own.

What I Built

AXIS is a desktop accessibility auditor for Windows that renders JavaScript-heavy pages using a headless Chrome engine, audits against WCAG 2.2, WCAG 2.1, Section 508, and India's RPwD Act, scores pages from 0–100 with a compliance tier, estimates the page's carbon footprint, and exports TXT and PDF reports.

But the more interesting part was what came next.

The SDK Idea

Once the core audit engine was working, I realized it was completely decoupled from the UI. So I extracted it into AXIS-CORE — a standalone library that any developer could drop into their own tooling or CI/CD pipeline.

var checker = new AxisCore();
var report = await checker.CheckUrlAsync("https://example.com");
Console.WriteLine($"Score: {report.AccessibilityScore}/100");

Then I thought — why stop at .NET?

Shipping to Three Registries

I ported the SDK to JavaScript and Rust, and published all three:

Runtime	Package
.NET	AXIS-CORE on NuGet
JavaScript	axis-core-sdk on npm
Rust	axis-core on Cargo

Each one went through the full publish cycle — versioning, package metadata, README, API surface design. It took longer than I expected. Way longer.

What I didn't expect

Publishing to NuGet is surprisingly strict compared to npm. You need proper package metadata, a valid license SPDX expression, and a README that actually renders correctly in their portal. My first few attempts were rejected silently — the package appeared listed but showed no description.

Cargo was the smoothest. The cargo publish workflow is well-documented and the tooling catches most mistakes before you even push.

npm was the fastest to publish but the hardest to get right structurally. CommonJS vs ESM compatibility and making sure the package resolves correctly across Node versions took a few iterations.

WCAG 2.2 — What's Actually New

This was the part I had to research most deeply. Two new criteria stood out.

2.5.8 — Target Size Minimum (Level AA)

Clickable elements need a minimum area of 24×24 CSS pixels. Sounds obvious, but a surprising number of icon buttons and inline links fail this.

button, a {
  min-width: 24px;
  min-height: 24px;
  padding: 8px 12px;
}

3.3.7 — Redundant Entry (Level A)

Forms collecting personal data must use autocomplete attributes. This one is almost universally ignored.

<input type="email" name="email" autocomplete="email">
<input type="tel"   name="phone" autocomplete="tel">

AXIS checks both automatically.

The Environmental Angle

One feature I added on a whim turned out to be the most talked-about when I demoed it — a carbon footprint estimate per page load.

It factors in page weight, request count, CDN usage, and estimated server energy draw, then gives a rating:

Rating	CO₂ per page load
🌱 Eco	< 10 g
🟡 Moderate	10 – 50 g
🔴 High Impact	> 50 g

It's not scientific-grade, but it makes people think — which was the point.

What I Learned

Designing a public API is hard. When it's just your own app, you can change internals freely. Once it's a published package, breaking changes have real consequences. I had to think carefully about naming, return types, and async patterns before publishing v1.

Documentation is the product. Nobody will use your package if the README doesn't immediately show them what it does and how to install it. I rewrote the README three times.

Multi-runtime is a commitment. Keeping three SDKs in sync across .NET, JavaScript, and Rust means any core logic change needs to propagate to all three. I underestimated this. Python support is planned but I'm being careful about when I take that on.

Organic downloads feel different. Seeing strangers install something you built without you telling them to is a genuinely different feeling from a project that only your professor sees.

What's Next

Python SDK on PyPI, a GitHub Actions integration so teams can run AXIS checks in CI without writing any code, and a VS Code extension companion — A11Y: Lazy Edition is already live for in-editor checks.

Try it

Release
NuGet: dotnet add package AXIS-CORE
npm: npm install axis-core-sdk
Cargo: cargo add axis-core

If you're building anything where accessibility matters or just want to know your page's carbon footprint, give it a try. And if you've shipped a multi-runtime SDK before, I'd love to know how you handled keeping them in sync.

Built with WPF · .NET 9 · C# · HtmlAgilityPack · PuppeteerSharp · QuestPDF

Main changes: collapsed the bullet-heavy "What's Next" into a paragraph, merged the fragmented "What I Learned" bullets into flowing prose, and removed the section separators that were making it feel templated.

IndiaFoss Banglore Journey

Abhiram — Thu, 19 Mar 2026 18:37:23 +0000

IndiaFOSS Summit Bangalore 2025 — When an Idea Turned Into a Movement

I walked into the IndiaFOSS Summit in Bangalore not just expecting tech talks or networking opportunities, but hoping for inspiration. What I left with was far more — a renewed belief in open source, new professional connections, and a deeper sense of what impact really looks like.

Day 1: The Spark
From the very first session, it was clear this wasn’t just a meetup of coders. It was a convergence of people who think, build, and dream differently.

Kailash Nadh’s talk stood out. He reminded us that open source is more than just code — it’s about contribution, community, and leaving behind tools that will continue to serve people long after we’re gone. That struck a chord with me.

Over coffee breaks and hallway conversations, I found myself speaking to project leads, student innovators, and people who’ve spent years shaping the open-source ecosystem. Each conversation felt like a window into what’s possible when curiosity meets action.

Meeting Industry Voices

One of the highlights was meeting senior figures from Zeiss.

The Product Head — a German expert Helge Anderson — spoke about how the company manages the balance between innovation and responsibility across its global operations. HR leaders gave an honest view of their culture: they notice and value people who take initiative instead of waiting passively for opportunities.

Technical leads, architects, and cloud engineers also connected with me on LinkedIn. For a student, that’s not just a contact list — it’s a reminder that conversations can open doors.

What impressed me most was the tone of these interactions. They weren’t scripted Q&As. They were genuine exchanges — “What drives you?” “Where do you see yourself?” “How do you think open source will matter in the next five years?”

The Joy of Serendipity

Some of the most unforgettable moments happened outside the scheduled sessions:

On the train, a co-passenger — an elderly lady from Kerala — struck up a conversation. Before we parted ways, she told me she saw me as her grandson and blessed me for future success.

On the way to Bangalore, I spoke with an industrialist who turned into an unexpected mentor. His advice was simple but sharp: “Don’t rush into flashy labels like entrepreneurship. Focus on solving real problems, gain real-world exposure, and everything else will follow.”

During sessions, engineers and founders from Aftershoot, Flexprice, and other startups engaged with me — not in a “networking” sense, but genuinely curious about my ideas, the challenges I’m working on, and how I plan to take them forward.

Lessons Learnt (Beyond the Slides)

Authenticity > Polish
You don’t need perfect English, perfect Malayalam, or flawless slides. What people notice is your curiosity, your respect, and your intent.
Approach, don’t wait
The biggest leaders are often the most approachable — but only if you take the first step. Waiting silently doesn’t get noticed.
Execution matters more than ideas
Everyone has ideas. Few follow through. Conversations kept circling back to one point: sharpen what matters and build consistently.
Open source is for everyone
Even if you don’t write a single line of code, you can still contribute — through accessibility tools, design, documentation, or building supportive communities.
Connections are human, not transactional
Handshakes, laughter, shared meals, and honest questions build stronger bonds than polished résumés or forced pitches.
Mentorship comes in unexpected forms
Sometimes it’s not a keynote speaker but a co-passenger or a stranger in the hallway who drops the advice you’ll remember years later.
Your story matters
People don’t just ask “What do you do?” They ask “Why do you do it?” Having a story — even if it’s still unfolding — makes a difference.

What’s Next for Me

The summit gave me a strong push to expand my Web Accessibility Checker project. I’m making it fully open source and extending it across platforms — web, Android, and desktop.

I’ll keep refining it, taking feedback, and sharing progress publicly. My goal is that next time I walk into an event like this, I’ll be attending not just as a learner, but as a contributor with something meaningful to showcase.

Final Thought

If there’s one thing I’ve taken away, it’s this: Don’t attend events just to listen. Attend to connect, to ask, to share, to build.

Because sometimes, the most important part of a summit isn’t on the stage — it’s in a hallway chat, a train ride, or a stranger’s blessing

Introducing🥁 my CLI based NUMERICAL SYSTEM CALCULATOR and SCRIPT DETECTOR

Abhiram — Mon, 23 Sep 2024 16:10:58 +0000

Multi-Dimensional Calculator

Decimal Conversion

This Rust project demonstrates how to perform number conversions with decimal points using a user-defined module. The project uses the rust_decimal crate for high-precision decimal arithmetic.

Conversion from base to another with a accuracy upto a base of of 32 [for high accuracy]

Area Calculator

This rust project was upgraded with ability to calculate areas of:-

Square
Rectangle
Triangle
Circle
Regular polygon with n side

and ability to convert into various units.

Temperature Convertor

A ability to convert from temperatures units of celcius,fahrenheit,kelvin,rankine fom one another.

Also it can convert from one unit to another with a accuracy upto 4 decimal places.

Lenght Convertor

This project was upgraded with ability to convert from length units of meter,centimeter,inch,foot,yard,mile.

Physics Calculator

this project was upgraded with ability to calculate:-

mass
foce
energy
velocity
pressure
acceleration
volume

and ability to convert into various units.

Miscellaneous Operation

Angle operations
Data Transfer unis
Fuel Economy units

Time Operation

Time conversion from one unit to another
Time calculation of time difference between two time
Calculate effiency of a work

Fuel Calculations

Get ideas about efficiency
get knowledge about environmental issues like carbon footprint
Annual Fuel Cost
Fuel consumptions
Monthly savings when buying a new car

Data Transfer

Converting into various bases
Network Speed predictor
Network Statistics

Language and Script Pedictor

Write a text/copy the text from another source and paste here it to get the language and script details
Added system relaiblity and predicatbilty showing how much reliable the data is

Project Structure

src/
- main.rs: The main entry point of the application.
- arithmetic.rs: A module containing functions for arithmetic operations.
- area.rs: A module containing functions for area calculations.
- data.rs : A module containing operations for data transfer speed.
- physics.rs: A module containing details about physics operation.
- lenght.rs : Amodule containg information about lenght operations
- physicc.rs: A subpart module of physics.rs containg operation about convertsion from one base to another
- tempe.rs: A module containing details of temperature.
- time.rs: A module containg details of time operations.
target/
- contains debugging files
cargo.lock
cargo.toml

Dependencies

rust_decimal: A crate for high-precision decimal arithmetic.
rust_decimal_macros: A crate for creating decimal literals.

Add the following to your Cargo.toml file:

[dependencies]
rust_decimal = "1.36"
rust_decimal_macros = "1.36"
whatlang="0.16.4"

Please adhere to this project's `code of conduct`and support the developer with a follow and star.

Development of project completed on 9/21/2024 at 7:44 UST

For any suggestions and changes please free to comment.Please do like♥️the post for encouraging me to do more such works

Author

@ABHIRAM-CREATOR06

WHICH SUPERHERO ARE YOU????

Abhiram — Sun, 22 Sep 2024 16:14:21 +0000

🦸 Build a Superhero Prediction Model Using Python

Ever wondered which superhero matches your traits the best? Let’s build a Python project that predicts which superhero you're most like based on your strength, intelligence, speed, agility, and durability. It’s a fun and practical machine learning exercise! 🚀

🌟 Project Overview

In this project, we'll:

Create a dataset of superhero attributes.
Train a machine learning model to classify superheroes based on their characteristics.
Allow users to input their own traits and get matched with a superhero.

🛠️ Tech Stack:

Python 🐍
Pandas for data manipulation
Scikit-learn for model building and prediction
Logistic Regression for classification
CSV for handling the superhero dataset

📑 Project Steps

Setup the Superhero Dataset: We’ll use a CSV file to store our superheroes and their respective traits.
Train the Machine Learning Model: We'll use Logistic Regression to classify superheroes based on their attributes.
User Input: Let users input their own characteristics and predict their superhero match!

🦸‍♂️ Superhero Dataset

We'll create a CSV file containing a list of superheroes and their attributes: strength, intelligence, speed, agility, and durability. Here’s an example dataset:

Strength	Intelligence	Speed	Agility	Durability	Superhero
8	7	6	5	9	Superman
5	9	4	7	6	Batman
6	6	9	8	5	Flash
7	8	5	6	7	Wonder Woman
9	5	7	6	8	Thor
4	10	3	9	4	Iron Man
7	6	8	7	6	Spider-Man

You can create your own dataset using this template!

Visit my Github for complete code

Feel to inform about your queries, suggestions and futher development ideas and do aupport this project by like ♥️ the project for effort put by the dev.

Follow ** my **github for more such interesting projects

Numeric Convertion

Abhiram — Sat, 14 Sep 2024 11:14:17 +0000

Logical Number Conversion using Rust

Fed up with stupid calculations in logic system design told a friend, found solution thanks to my best friend RUST

Welcome to the Base Converter project! This Rust application allows you to convert numbers from any logical base to another. Whether you’re working with binary, hexadecimal, or any other base, this tool has got you covered.

Features

Convert numbers between any two bases (2-36)
User-friendly command-line interface
Error handling for invalid inputs
Efficient and fast conversion algorithms

Working

Cargo.toml dependecies

[dependencies] rust_decimal = "1.36" rust_decimal_macros = "1.36"

Code available at Github

Hope you all this and please share your opinion and modifications...
Thank you

Frontend Attempt

Abhiram — Thu, 05 Sep 2024 17:00:05 +0000

This is a submission for Frontend Challenge v24.09.04, Glam Up My Markup: Space

What I Built

I built a space-themed landing page that provides information about space exploration. The goal was to create an attractive, minimalistic design that highlights key aspects of space history, current missions, future missions, and more. The page includes sections for home, about, history, current missions, future missions,a questionnaire, and contact information.

Demo

You can view the project live here. Below is a screenshot of the landing page:

Space Exploration Landing Page

You can also check out the code on Github

Journey
Creating this project was an exciting journey. Here are some key points about the process:

Design and Layout: I aimed for a clean and minimalistic design with a dark, space-themed background to create an immersive experience. The layout is simple yet informative, making it easy for users to navigate through different sections.

Content: I included detailed information about the history of space exploration, current and future missions. The questionnaire section allows users to interact and share their thoughts on space exploration.

Challenges: One of the challenges was ensuring that the animations interactivity worked smoothly across different devices and screen sizes. I learned a lot about responsive design and cross-browser compatibility during this process.

Future Plans: I plan to add more interactive elements, such as a quiz about space facts and a timeline of significant events in space exploration. I also hope to integrate more advanced animations and transitions to make the page even more engaging.

CODE

HTML

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Space Exploration</title>
    <link rel="stylesheet" href="styles.css">
</head>
<body>
    <header class="space-background">
        <h1>Welcome to Space Exploration</h1>
        <nav>
            <ul>
                <li><a href="#home">Home</a></li>
                <li><a href="#about">About</a></li>
                <li><a href="#history">History</a></li>
                <li><a href="#current-missions">Current Missions</a></li>
                <li><a href="#future-missions">Future Missions</a></li>
                <li><a href="#questionnaire">Questionnaire</a></li>
                <li><a href="#contact">Contact</a></li>
            </ul>
        </nav>
    </header>
    <main class="space-background">
        <section id="home">
            <h2>Home</h2>
            <p>Discover the wonders of the universe and our journey into space.</p>
        </section>
        <section id="about">
            <h2>About</h2>
            <p>Learn about the history and future of space exploration.</p>
        </section>
        <section id="history">
            <h2>History of Space Exploration</h2>
            <h3>1. Early Concepts (Pre-20th Century)</h3>
            <p><strong>Ancient Civilizations:</strong> Ancient cultures like the Babylonians, Egyptians, Greeks, and Chinese were among the first to study the stars and celestial objects, laying the foundation for astronomy.</p>
            <p><strong>17th Century:</strong> Johannes Kepler’s laws of planetary motion and Isaac Newton’s law of universal gravitation provided the necessary understanding for future space travel concepts.</p>
            <h3>2. Early 20th Century</h3>
            <p><strong>Tsiolkovsky's Rocket Equation (1903):</strong> Russian scientist Konstantin Tsiolkovsky proposed the idea of space travel using rockets and formulated the Tsiolkovsky rocket equation, a fundamental principle in astronautics.</p>
            <p><strong>Robert Goddard (1926):</strong> An American physicist, Robert Goddard, successfully launched the world's first liquid-fueled rocket, proving that space travel was possible.</p>
            <h3>3. The Space Race (1950s-1970s)</h3>
            <p><strong>Sputnik 1 (1957):</strong> The Soviet Union launched the first artificial satellite, Sputnik 1, into space, marking the beginning of the Space Age.</p>
            <p><strong>Yuri Gagarin (1961):</strong> Soviet cosmonaut Yuri Gagarin became the first human to orbit Earth aboard Vostok 1, a major milestone in space exploration.</p>
            <p><strong>Apollo 11 (1969):</strong> The United States' NASA successfully landed astronauts Neil Armstrong and Buzz Aldrin on the Moon, with Armstrong famously declaring, "That's one small step for man, one giant leap for mankind."</p>
            <h3>4. Post-Moon Landings and the Space Shuttle Era (1970s-1990s)</h3>
            <p><strong>Space Stations:</strong></p>
            <ul>
                <li><strong>Salyut and Mir (1971-1986):</strong> The Soviet Union launched a series of space stations, culminating in the long-lasting Mir, which operated until 2001.</li>
                <li><strong>Skylab (1973):</strong> The United States launched its first space station, Skylab, which was operational for six years.</li>
            </ul>
            <p><strong>Space Shuttle Program (1981-2011):</strong> NASA’s reusable Space Shuttle fleet completed 135 missions over 30 years, including launching satellites, conducting scientific research, and assembling the International Space Station (ISS).</p>
            <h3>5. International Cooperation and Space Exploration (1990s-Present)</h3>
            <p><strong>International Space Station (ISS) (1998-present):</strong> A joint effort by NASA, Roscosmos (Russia), ESA (Europe), JAXA (Japan), and other partners, the ISS serves as a hub for scientific research and international collaboration in low Earth orbit.</p>
            <p><strong>Mars Exploration:</strong></p>
            <ul>
                <li><strong>Rovers and Orbiters:</strong> The Mars rovers like Spirit, Opportunity, Curiosity, and Perseverance have provided detailed information about the Martian surface and its potential to support life.</li>
                <li><strong>ExoMars (2020):</strong> A European-Russian mission designed to search for signs of life on Mars.</li>
            </ul>
            <h3>6. Private Space Exploration and the Future (2000s-Present)</h3>
            <p><strong>Commercial Spaceflight:</strong> Companies like SpaceX, Blue Origin, and Virgin Galactic are pioneering commercial space travel, aiming to make space more accessible to private individuals and researchers.</p>
        </section>
        <section id="current-missions">
            <h2>Current Missions</h2>
            <p>Explore the ongoing missions that are expanding our understanding of the universe.</p>
        </section>
        <section id="future-missions">
            <h2>Future Missions</h2>
            <p>Learn about the upcoming missions that aim to push the boundaries of space exploration.</p>
        </section>
        <section id="questionnaire">
            <h2>Questionnaire</h2>
            <form>
                <label for="name">Name:</label>
                <input type="text" id="name" name="name" required><br><br>

                <label for="email">Email:</label>
                <input type="email" id="email" name="email" required><br><br>

                <label for="question1">1. What is your favorite planet?</label><br>
                <input type="text" id="question1" name="question1" required><br><br>

                <label for="question2">2. Have you ever visited a space museum?</label><br>
                <input type="radio" id="yes" name="question2" value="yes">
                <label for="yes">Yes</label><br>
                <input type="radio" id="no" name="question2" value="no">
                <label for="no">No</label><br><br>

                <label for="question3">3. What interests you the most about space exploration?</label><br>
                <textarea id="question3" name="question3" rows="4" cols="50" required></textarea><br><br>

                <input type="submit" value="Submit">
            </form>
        </section>
        <section id="contact">
            <h2>Contact</h2>
            <p>Get in touch with us for more information about space exploration.</p>
        </section>
    </main>
    <footer class="space-background">
        <p>© 2024 Space Exploration. All rights reserved.</p>
    </footer>
</body>
</html>

CSS

* {
    margin: 0;
    padding: 0;
    box-sizing: border-box;
}

body {
    font-family: Arial, sans-serif;
    line-height: 1.6;
    background-color: #000;
    color: #fff;
}

.space-background {
    background: rgba(0, 0, 0, 0.8) url('https://www.nasa.gov/sites/default/files/thumbnails/image/potw2048a.jpg') no-repeat center center;
    background-size: cover;
}

header {
    padding: 1rem 0;
    text-align: center;
}

header h1 {
    margin-bottom: 0.5rem;
}

nav ul {
    list-style: none;
    padding: 0;
}

nav ul li {
    display: inline;
    margin: 0 10px;
}

nav ul li a {
    color: #fff;
    text-decoration: none;
}

main {
    padding: 2rem;
}

section {
    margin-bottom: 2rem;
}

form {
    background: rgba(255, 255, 255, 0.1);
    padding: 1rem;
    border-radius: 5px;
}

form label {
    display: block;
    margin-bottom: 0.5rem;
}

form input[type="text"],
form input[type="email"],
form textarea {
    width: 100%;
    padding: 0.5rem;
    margin-bottom: 1rem;
    border: none;
    border-radius: 5px;
}

form input[type="submit"] {
    background: #333;
    color: #fff;
    border: none;
    padding: 0.5rem 1rem;
    border-radius: 5px;
    cursor: pointer;
}

form input[type="submit"]:hover {
    background: #555;
}

footer {
    text-align: center;
    padding: 1rem 0;
    position: fixed;
    width: 100%;
    bottom: 0;
}

Team
This project was a solo effort, but I would like to credit the following resources and inspirations:

NASA for the stunning space images.
MDN Web Docs for the excellent documentation on web development.

License
This project is licensed under the MIT License. Feel free to use and modify the code as you see fit.

Python Project: Movie Suggestion System

Abhiram — Wed, 04 Sep 2024 13:16:33 +0000

Build a Movie Suggestion Machine with Python and Tkinter

Introduction

Struggling to decide which movie to watch next? The Movie Suggestion Machine is here to help! This Python-based GUI application suggests movies based on genres, allows you to search for specific movies, and provides cast and crew information. It also includes light/dark mode and full-screen mode for a better user experience.

Features

Suggest Movies: Get movie suggestions based on genres.
Search Movies: Search for movies by name.
Get Cast and Crew: Retrieve cast and crew information.
Toggle Theme: Switch between light and dark modes.
Full-Screen Mode: Enable full-screen mode with larger icons and buttons.

How It Works

Suggest Movies: Enter a genre to get movie suggestions.
Search Movies: Enter a movie name to search for movies.
Get Cast and Crew: Enter a movie name to retrieve cast and crew information.
Toggle Theme: Switch between light and dark modes.
Full-Screen Mode: Press F11 to toggle full-screen mode. Press Escape to exit.

Conclusion

The Movie Suggestion Machine is a fun and useful project that showcases the power of Python and Tkinter for building GUI applications. Check out the GitHub repository for more details and to contribute!
Github Repository

Feel free to customize this further to suit your needs. Let me know if you need any more help!

DEV Community: Abhiram

We Built a Signal Protocol Messenger. Then We Checked If It Was Legal in 5 Jurisdictions.

Quick Architecture Recap

1. European Union — Chat Control / CSAR

2. United States — EARN IT Act + PQC Executive Order

3. India — IT Rules 2021, Rule 4(2) Traceability

4. United Kingdom — Online Safety Act 2023 + Investigatory Powers Act 2016

5. UN Convention Against Cybercrime

The Cross-Jurisdiction Picture

The Architectural Observation That Matters More Than the Jurisdiction Table

What We Are Watching

Conclusion

Halonyx, Part 2: Interactive Backend Simulator

What it is

What the 14 steps cover

Why HTML, CSS, and JavaScript with no dependencies

The part I was most uncertain about

Try it

I Built a Signal Protocol Messenger from Scratch with X3DH, Double Ratchet, Safety Numbers, P2P File Transfer

Why Build Another Messenger?

The Core Problem: Trust No Server

Signal Protocol: What's Actually Happening

X3DH Key Exchange

Double Ratchet

Safety Numbers: Closing the MITM Gap

P2P File Transfer via WebTorrent

Database Architecture: Dual Isolation

Offline Mailbox: At-Most-Once Delivery

Cryptographic Primitives Summary

What We Got Wrong (and Fixed)

Roadmap

Try It / Contribute

I Built a WCAG 2.2 Accessibility Checker and Shipped Its SDK to Three Package Registries as a CS Student published: true

I Built a WCAG 2.2 Accessibility Checker and Shipped Its SDK to Three Package Registries as a CS Student

The Problem

What I Built

The SDK Idea

Shipping to Three Registries

What I didn't expect

WCAG 2.2 — What's Actually New

2.5.8 — Target Size Minimum (Level AA)

3.3.7 — Redundant Entry (Level A)

The Environmental Angle

What I Learned

What's Next

Try it

IndiaFoss Banglore Journey

Meeting Industry Voices

The Joy of Serendipity

Lessons Learnt (Beyond the Slides)

What’s Next for Me

Final Thought

Introducing🥁 my CLI based NUMERICAL SYSTEM CALCULATOR and SCRIPT DETECTOR

Multi-Dimensional Calculator

Decimal Conversion

Area Calculator

Temperature Convertor

Lenght Convertor

Physics Calculator

Miscellaneous Operation

Time Operation

Fuel Calculations

Data Transfer

Language and Script Pedictor

Project Structure

Dependencies

Please adhere to this project's code of conductand support the developer with a follow and star.

Development of project completed on 9/21/2024 at 7:44 UST

Author

WHICH SUPERHERO ARE YOU????

🦸 Build a Superhero Prediction Model Using Python

🌟 Project Overview

🛠️ Tech Stack:

📑 Project Steps

🦸‍♂️ Superhero Dataset

Numeric Convertion

Logical Number Conversion using Rust

Features

Working

Cargo.toml dependecies

Please adhere to this project's `code of conduct`and support the developer with a follow and star.