Welcome to Alnoms

Alnoms is a Performance Intelligence Engine that detects performance risks, scalability bottlenecks, and inefficient execution paths before they reach production.

Built by Arprax, It combines static analysis, runtime profiling, and system-level reasoning into a deterministic intelligence engine for engineering teams building high-performance software.

🌐 A Multi-Surface Intelligence Engine

Alnoms integrates seamlessly into your existing engineering workflows. Catch algorithmic regressions (\(O(N^2)\), \(O(N^3)\)) exactly where it makes the most sense for your team:

💻 Local CLI: Deep empirical profiling in your terminal (pip install alnoms).
🛠️ VS Code Extension: Real-time static analysis and cost diagnostics directly inside your IDE while you type.
⚙️ GitHub Actions: Automated PR gatekeeping to block inefficient code before it merges.

⚡ Live Performance Lab (Beta)

Test the analyzer directly in your browser using a sandboxed runtime. Paste your Python script below. The Performance Intelligence Engine will audit it in your browser.

Loading...

Results will appear here...

🧭 Core Principles & Status

Alnoms operates on a single design principle: Performance must be explained, not guessed. Every result is deterministic, reproducible, and empirically validated.

Pattern Detection: Identifies inefficient algorithmic structures in raw code.
Deterministic Optimization: Applies rule-based transformations instead of heuristics.
Verifiable Performance: Compares asymptotic complexity and runtime before/after optimization.

System Status: 🟢 Core Engine: Stable | 🟢 Profiler: Stable | 🟡 Pattern Registry: Expanding | 🟠 Live Lab: Beta

🗺️ System Overview & Routing

Alnoms bridges the gap between theoretical complexity and real-world execution. Explore the architecture below:

🚀 Getting Started — Install the library and run your first audit.
⚙️ Core System — Understand the internal architecture (Analyzer, Decision Engine, and Fixers).
🧩 Pattern Registry — View the catalog of inefficient structures we detect (e.g., Nested Loops, Membership Traps).
📊 Verification & Proof — Review our empirical benchmarks, complexity proofs, and case studies.

⚡ Quick Start: Catching a Silent Trap

Let's look at a real-life example. You have a script (slow_script.py) that cross-references data:

"""Inefficient script used for the Alnoms demonstration."""

def slow_membership_sum(arr):
    total = 0
    for x in arr:
        # Intentional O(N^2) membership trap
        if x in arr:
            total += x
    return total

# Required for empirical scaling
def data_gen(n):
    return (list(range(n)),)

if __name__ == "__main__":
    data = list(range(200))
    print(slow_membership_sum(data))

Run an automated algorithmic audit on your script:

alnoms analyze slow_script.py --deep --start-n 50 --rounds 4

Example Output:

==================================================
⚖️ PERFORMANCE REPORT
==================================================
File: examples/alnoms/scripts/slow_script.py
Timestamp (UTC): 2026-04-20T21:24:34.294600Z
Total Execution Time: 0.0035s

🧠 DETECTED INTENT:
   Membership test ('in arr') inside loop

🚨 STATIC ANALYSIS (Diagnostics & Suggestions)
--------------------------------------------------
1. ⚠️ ISSUE: Membership test ('in arr') inside loop (Function: slow_membership_sum | Line: 7)
   📖 Explanation: Membership checks on lists inside loops are O(N). Convert to a set for O(1) lookups.
   💊 RECOMMENDED OPTIMIZATION: O(N)
   🏗️ IMPLEMENTATION: alnoms.dsa.structures.separate_chaining_hash_st
   🔐 ACCESS TIER: OSS
   ⏱️ Complexity Shift: O(N*M) → O(N + M)

   💡 SUGGESTED FIX:
   --- BEFORE ---
   |  for k in keys:
   |      if k in items:
   |          process(k)
   --- AFTER ---
   |  items_set = set(items)
   |  for k in keys:
   |      if k in items_set:
   |          process(k)

⏱️ DYNAMIC PROFILING (Top Execution Bottlenecks)
--------------------------------------------------
   1. slow_membership_sum() -> 7e-05s (2.15%)

📈 EMPIRICAL SCALING ANALYSIS: slow_membership_sum()
--------------------------------------------------
N          | Time (s)     | Ratio    | Est. Complexity
--------------------------------------------------
50         | 0.00001      | -        | Initial Round  
100        | 0.00002      | 3.32     | O(N^2)         
200        | 0.00008      | 3.91     | O(N^2)         
400        | 0.00028      | 3.59     | O(N^2)         

⚖️ VERDICT:
⚠️ WARNING: Function operates at O(N^2). May not scale efficiently.

📌 CONTEXT
--------------------------------------------------
   Empirical scaling validates asymptotic behavior under increasing load.

🚀 EXPECTED IMPACT
--------------------------------------------------
   For N = 10,000:
     • O(N²) → ~100,000,000 operations
     • O(N)  → ~10,000 operations
   Estimated improvement: 100×–1000× depending on workload.

🤖 CONFIDENCE
--------------------------------------------------
   High — static and empirical signals agree.

🔁 AFTER OPTIMIZATION (SIMULATED)
--------------------------------------------------
   Expected Complexity: O(N)
   Behavior: Linear scaling with stable performance.
   Suggested Implementation:
       s = set(arr)
       for x in arr:
           if x in s:
               total += x

==================================================

This is algorithmic intelligence, not just profiling.

See how to apply the fix and verify the performance →

📦 Installation

# Core framework and CLI
pip install alnoms

▶ Next Steps

Start here:

📚 Citation

To cite the Software: See the "Cite this repository" button on our GitHub.

Software:

@software{alnoms2026,
  author       = {Chowdhury, Tanmoy},
  title        = {Alnoms: A Performance Intelligence Engine for Computational Analysis},
  year         = {2026},
  url          = {https://alnoms.com},
  note         = {Available at https://github.com/arprax/alnoms}
}