01 THE OPEN ARCHITECTURE LAB

Code in the open.
Engineered for production.

We engineer sovereign software primitives, libraries, and tools shared freely with the developer community. No crippled “community editions,” no tracking beacons, and no hidden cloud paywalls.

Abeta GitHub Org Contributor Showcase →

5Active Open Source Repositories

100%Permissive MIT & Apache 2.0

31Modular Go & React Packages

0Surveillance Cookies or Telemetry

02 CORE REPOSITORIES

Production libraries.
Extracted from real systems.

Every library we publish is extracted from production code handling real traffic, high-concurrency API calls, and regulated financial settlement.

@abeta.dev/react-libs

v0.17.0

Production-ready React 19 UI component primitives and headless state machines.

TypeScriptMIT

High-craft React 19 component library engineered for modern web applications. Strict TypeScript typing, atomic tree-shakable submodule exports, Tailwind CSS v4 design tokens, accessible ARIA patterns, and local-first headless state management.

npm install @abeta.dev/react-libs

PRODUCTION HIGHLIGHTS

React 19 Server Components & Actions ready
Tailwind CSS v4 CSS-first design token architecture
Submodule atomic imports for zero unused code in production bundles

BEST FOR

Editorial SaaS dashboards and design systemsHigh-performance Next.js 16 App Router web applicationsLocal-first client applications with zero-cookie constraints

go-libs

v1.4.0

Zero-business-logic Go libraries and Gin middleware suite for cloud-native services.

GoMIT

A collection of 31 modular, production-tested Go utility packages and Gin middleware components designed for high-concurrency microservices. Includes distributed circuit breaking, rate limiting, worker pools, cache invalidation, and OpenTelemetry instrumentation.

go get github.com/Abeta-dev/go-libs

PRODUCTION HIGHLIGHTS

Sonyflake 64-bit distributed unique ID generator
Circuit Breaker based on Sony/gobreaker with configurable state transitions
Sliding-window token bucket distributed rate limiting

BEST FOR

Production Go microservices and API gatewaysResilient HTTP service-to-service communication with circuit breakersHigh-throughput distributed event processors and background workers

go-fintech-india

v0.9.2

Zero-dependency Go library for Indian fintech, statutory checks, and exact paise math.

GoMIT

Standardized, zero-dependency Go implementation of Indian financial and regulatory primitives. Features exact 64-bit integer paise arithmetic (preventing IEEE 754 floating point drift), UIDAI Verhoeff Aadhaar checksum, PAN entity classification, GSTIN Mod-36 validation, and offline RBI IFSC directory resolution.

go get github.com/Abeta-dev/go-fintech-india

PRODUCTION HIGHLIGHTS

Paise integer arithmetic eliminates floating point rounding errors in financial ledgers
Zero-allocation Verhoeff D8 dihedral algorithm for UIDAI Aadhaar number verification
GSTIN Mod-36 Luhn-variant checksum and state code classification

BEST FOR

UPI and payment gateway settlement engines in IndiaGST compliant invoicing and ledger generation systemsKYC onboarding verification pipelines (Aadhaar, PAN, GSTIN, Bank IFSC)

go-app-kit

v0.7.0

Enterprise domain accelerator: Transactional Outbox, audit trails, and PDF invoicing.

GoMIT

A structured Go enterprise accelerator designed for mission-critical domain services. Implements the Transactional Outbox pattern for zero-loss message delivery, tamper-evident cryptographic audit trails, and Indian localized PDF invoicing.

go get github.com/Abeta-dev/go-app-kit

PRODUCTION HIGHLIGHTS

Transactional Outbox pattern guarantees at-least-once delivery with no dual-write bugs
Cryptographically chained SHA-256 tamper-evident immutable audit trails
Server-side localized GST PDF invoice generation with HSN/SAC breakdowns

BEST FOR

Mission-critical financial accounting systemsEvent-driven architectures using Kafka, RabbitMQ, or AWS SQS with Outbox safetyCompliance-mandated audit logging for regulatory inspection

cloud-native-observability

v2.1.0

Enterprise LGTM observability stack, OpenTelemetry, and SRE burn-rate SLO alerting.

HCL / KubernetesApache-2.0

Turnkey production observability infrastructure defined as code. Features the full LGTM stack (Loki for logs, Grafana for visualization, Tempo for traces, and Prometheus/Thanos for long-term metrics), OpenTelemetry Collector deployment patterns, and Google SRE multi-window burn-rate SLO alerting configured via ArgoCD GitOps.

git clone https://github.com/Abeta-dev/cloud-native-observability.git

PRODUCTION HIGHLIGHTS

Complete LGTM stack setup in Kubernetes with zero licensing costs
Google SRE multi-window multi-burn-rate SLO alerting rules (99.9% and 99.99%)
End-to-end trace-to-log correlation via Tempo and Loki span ID mapping

BEST FOR

Cloud-native Kubernetes platforms requiring enterprise observabilityTeams replacing expensive Datadog/NewRelic bills with open-source LGTM stackSRE teams enforcing Google-style Error Budgets and multi-window burn rate alerts

03 LIVE CODE BLUEPRINTS

Inspect the mechanics.
Runnable, zero-fluff code.

Switch between our core repositories to examine concrete implementations: exact paise money math, distributed circuit breakers, transactional outbox event streams, and Google SRE error budget alerts.

checkout-modal.tsxTypeScript

GitHub

1import { Button, Dialog, TokenProvider } from '@abeta.dev/react-libs'
2import { useState } from 'react'
3 
4export function PaymentDialog() {
5  const [isOpen, setIsOpen] = useState(false)
6 
7  return (
8    <TokenProvider theme="editorial-ink">
9      <Dialog 
10        open={isOpen} 
11        onOpenChange={setIsOpen}
12        trigger={
13          <Button variant="primary" size="md">
14            Authorize Settlement ↗
15          </Button>
16        }
17      >
18        <div className="dialog-content">
19          <h3>Cryptographic Verification</h3>
20          <p>Local-first memory ring buffer transaction verified.</p>
21        </div>
22      </Dialog>
23    </TokenProvider>
24  )
25}

04 OUR OPEN SOURCE ETHOS

How we build in public.
Four guiding principles.

Software is a cultural and intellectual craft. Here are the core commitments that govern every repository we publish under the Abeta umbrella.

01

Zero Artificial Lock-In

We license our work under MIT or Apache 2.0. We never withhold critical clustering, high-availability, or security features behind proprietary enterprise licenses. If it is in the repository, it works at full scale.

02

Exact Precision & Zero Allocations

In financial systems and high-throughput proxies, floating point math and excessive heap allocations cause catastrophic failure. We build with 64-bit integer arithmetic, object pools, and deterministic verification.

03

Local-First & Sovereign

Our client libraries never phone home with covert tracking beacons or analytics dossiers. State belongs on the user’s machine, replicated deterministically when requested, never surveilled without consent.

04

Welcoming Contributor Governance

Great open source thrives on thoughtful reviews and transparent RFCs. We curate clear issue descriptions, provide responsive PR reviews, and celebrate community members on our Contributor Leaderboard.

05 JOIN THE OPEN LAB

Ready to ship code
with Abeta?

Whether you are submitting an RFC for a new Go middleware package, polishing React 19 component tokens, or fixing an edge case in Indian GSTIN validation, we welcome your pull requests.

Explore Open Issues on GitHub View Community Showcase