If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/OpenGenus/cosmos shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

WAIT — Stale — last commit 2y ago

• 26+ active contributors
• Distributed ownership (top contributor 49% of recent commits)
• GPL-3.0 licensed
• CI configured
• Tests present
• ⚠ Stale — last commit 2y ago
• ⚠ GPL-3.0 is copyleft — check downstream compatibility

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live OpenGenus/cosmos repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/OpenGenus/cosmos.

What it runs against: a local clone of OpenGenus/cosmos — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in OpenGenus/cosmos | Confirms the artifact applies here, not a fork | | 2 | License is still GPL-3.0 | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 611 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of OpenGenus/cosmos. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/OpenGenus/cosmos.git
#   cd cosmos
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of OpenGenus/cosmos and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "OpenGenus/cosmos(\\.git)?\\b" \\
  && ok "origin remote is OpenGenus/cosmos" \\
  || miss "origin remote is not OpenGenus/cosmos (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(GPL-3\\.0)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"GPL-3\\.0\"" package.json 2>/dev/null) \\
  && ok "license is GPL-3.0" \\
  || miss "license drift — was GPL-3.0 at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 4. Critical files exist
test -f "README.md" \\
  && ok "README.md" \\
  || miss "missing critical file: README.md"
test -f ".github/CONTRIBUTING.md" \\
  && ok ".github/CONTRIBUTING.md" \\
  || miss "missing critical file: .github/CONTRIBUTING.md"
test -f "code/algorithm_applications/src" \\
  && ok "code/algorithm_applications/src" \\
  || miss "missing critical file: code/algorithm_applications/src"
test -f "code/artificial_intelligence/src" \\
  && ok "code/artificial_intelligence/src" \\
  || miss "missing critical file: code/artificial_intelligence/src"
test -f ".gitmodules" \\
  && ok ".gitmodules" \\
  || miss "missing critical file: .gitmodules"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 611 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~581d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/OpenGenus/cosmos"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

OpenGenus Cosmos is a massive contributor-driven, language-agnostic encyclopedia of algorithms and data structures with 4.8+ million lines of code across 40+ programming languages (C++, Python, Java, C, JavaScript, etc.). It provides production-ready implementations for classical algorithms (binary search, sorting, graph traversal, dynamic programming) and modern techniques (AI/ML models like Inception, VGG-11, autoencoders), organized under 25+ conceptual categories in the /code directory, used as the foundational dataset for OpenGenus's Quark Search Engine and IQ platform. Monorepo organized by algorithm category (not by language): /code/algorithm_applications, /code/artificial_intelligence, /code/data_structures, /code/graph_algorithms, etc. Within each category, subdirectories group related problems (e.g., /code/binary_search/ceil_of_element, /code/binary_search/floor_of_element). Each problem includes solutions in multiple languages side-by-side (e.g., strassens algorithm.cpp, CandyDistribution.java). Documentation is minimal per-file; README guides are centralized in /code/artificial_intelligence/src/*/README.md.

Competitive programmers preparing for technical interviews, computer science students building algorithm libraries for coursework, algorithm researchers needing canonical multi-language implementations, and contributors from the open-source community who maintain their own solutions in the repository.

Actively maintained and mature: the repo has 1000+ contributors, comprehensive CI/CD setup (Travis CI via .travis.yml), formal governance (CODE_OF_CONDUCT, CONTRIBUTING, PULL_REQUEST_TEMPLATE in .github/), and documented contribution workflows. However, the breadth (40+ languages, 25+ algorithm categories) means quality varies by section—some implementations are well-tested while others are skeleton code. This is a living community project, not a single-author library, so expect high variance in code maturity.

Key risks: (1) No monolithic test suite visible in file list—each algorithm/language combination likely has ad-hoc or no tests, making it unsafe to copy code without review. (2) Distributed, decentralized codebase means breaking changes or incorrect algorithms can slip through; validation burden is on the consumer. (3) Wide language/platform coverage (Assembly, Brainfuck, Processing, MATLAB) means some implementations are unmaintained niche contributions. (4) Large contributor base increases supply-chain risk—always audit code before production use.

No recent commit metadata is visible in the provided data, so activity cannot be confirmed. The repo structure is stable (well-established category organization, formal PR/issue templates), but the file list alone does not reveal current focus areas or active PRs. You should check GitHub's 'Insights' tab for commit frequency, open issues, and recent PRs to gauge current momentum.

git clone https://github.com/OpenGenus/cosmos.git
cd cosmos
# No build step required—this is a source code library, not a compiled package.
# Browse code in /code/<category>/<algorithm>/ for your language of choice.

Daily commands: This is not a runnable application—it's a code library. To use an algorithm: (1) Navigate to /code/<category>/<problem>/ (e.g., /code/binary_search/ceil_of_element/). (2) Pick a language implementation (e.g., ceil_of_element_in_sorted_array.cpp). (3) Compile and run manually or copy into your project. For AI/ML examples, navigate to /code/artificial_intelligence/src/<model>/ and open Jupyter notebooks (e.g., autoencoder.ipynb) in Jupyter or Google Colab.

• README.md — Entry point documenting the Cosmos project scope: a massive offline collection of algorithms, data structures, and ML implementations across 8+ languages.
• .github/CONTRIBUTING.md — Defines contribution standards and workflow for 600+ files maintained by hundreds of community members.
• code/algorithm_applications/src — Root directory for algorithm implementations—every contributor must understand the folder structure for adding new solutions.
• code/artificial_intelligence/src — Core ML/AI implementations including neural networks, GANs, and clustering—largest and most complex subsystem in the repo.
• .gitmodules — Defines external dependencies and submodule structure, critical for local setup and dependency resolution.
• .travis.yml — CI/CD pipeline configuration ensuring code quality gates across all algorithm and AI submissions.
• LICENSE — Legal terms governing contributions and code reuse across the massive collaborative dataset.

Add a New Algorithm Implementation

1. Create a new folder under code/algorithm_applications/src/{AlgorithmName}/ following existing naming conventions (code/algorithm_applications/src)
2. Implement the algorithm in your target language (C, C++, Java, Python) mirroring structure of similar algorithms like bubble_sort or binary_search (code/algorithm_applications/src/bubble_sort/bubble_sort_implementation.cpp)
3. Add a README.md documenting time complexity, space complexity, and use cases (code/algorithm_applications/src/binary_search)
4. Submit a pull request referencing the CONTRIBUTING.md guidelines and request review from maintainers (.github/CONTRIBUTING.md)

Add a New Machine Learning Model

1. Create a new folder under code/artificial_intelligence/src/{ModelName}/ with naming pattern matching existing models (code/artificial_intelligence/src)
2. Implement model in Jupyter Notebook (.ipynb) or Python script, following patterns from existing models like CNN or decision_tree (code/artificial_intelligence/src/convolutional_neural_network/cnn.ipynb)
3. Include datasets in folder (CSV, JSON) and add README.md with model architecture, hyperparameters, and results (code/artificial_intelligence/src/decision_tree/data_banknote_authentication.csv)
4. Reference research papers or documentation in model comments and submit via pull request with performance metrics (code/artificial_intelligence/src/image_processing/Cell-Segmentation/Reference Papers)

Add Support for a New Programming Language

1. Review README.md to confirm the language is not already supported, then propose addition in an issue (README.md)
2. Implement 3-5 core algorithms (e.g., bubble sort, binary search, merge arrays) in the new language under algorithm_applications folder (code/algorithm_applications/src/bubble_sort)
3. Update CONTRIBUTING.md with language-specific conventions, build instructions, and file organization rules (.github/CONTRIBUTING.md)
4. Create language-specific examples in AI section if applicable, then submit comprehensive pull request with documentation (code/artificial_intelligence/src)

Document a Data Structure Implementation

1. Identify the data structure type (linked list, tree, graph, hash table) and check if a folder exists; create if needed (code/algorithm_applications/src)
2. Create implementation files following naming conventions from adjacent folders (use descriptive names with underscores) (code/algorithm_applications/src/binary_search/first_and_last_position_in_sorted_array/firstAndLastPosInSortedArray.cpp)
3. Write comprehensive documentation covering operations, complexity analysis, and common use cases in a README file (code/artificial_intelligence/src/decision_tree)
4. Include example usage, test cases, and reference materials before submitting per CONTRIBUTING guidelines (.github/CONTRIBUTING.md)

• Multi-language implementation (C, C++, Java, JavaScript, Swift, Python, Go) — Enables developers to learn algorithms in their preferred language and bridges language communities into a unified knowledge base
• Jupyter Notebooks for ML/AI — Interactive format allows step-by-step execution, visualization, and rapid experimentation with datasets included inline
• GitHub as primary platform with Travis CI — Decentralized contribution model with automated validation ensures quality at scale across 600 files and hundreds of contributors
• Offline-first knowledge base (no database backend) — Users can clone entire repo locally, enabling learning without network dependency and integration into tools like Quark Search Engine

• Flat folder structure for algorithms vs. hierarchical taxonomy by complexity/domain

  • Why: Flat structure reduces barrier to contribution—new contributors easily find where to add code
  • Consequence: May become harder to navigate as repo grows beyond 600 files; requires strong README documentation

• Multiple languages in single repo vs. separate language-specific repos

  • Why: Single source of truth for algorithms enables cross-language comparison and unified dataset for tools like Quark Search
  • Consequence: Maintenance overhead increases; requires language-specific CI validators and contribution guidelines per language

• Jupyter Notebooks for ML vs. pure Python scripts

  • Why: Notebooks support inline datasets, visualizations, and explanatory markdown—better for learning
  • Consequence: Harder to version control diffs, larger file sizes, slower to clone; not suitable for production pipelines

• No central database or web API—static file collection

  • Why: Enables offline access and reduces infrastructure dependencies; simplifies deployment as static dataset
  • Consequence: Cannot track runtime metrics, community votes, or personalized learning paths; search must be index-based

• Real-time execution environment for code snippets
• Personalized learning recommendation engine
• Backend authentication or user accounts
• Production-ready ML model serving (educational/reference implementations only)
• Interactive IDE or live coding environment
• Mobile app distribution

No requirements.txt, package.json, pom.xml, or build configuration visible—there is no centralized dependency management because this is a multi-language, multi-category source repository, not a single application. Trap: Jupyter notebooks (.ipynb files) require Jupyter/IPython installed locally; Google Colab is not required but recommended. Trap: Some algorithms reference external data files (e.g., /code/algorithm_applications/src/Cichelli's Perfect Hashing Alogorithm/files/kywrdsOdd.txt); ensure these are downloaded or regenerated. Trap: C/C++ files have no visible Makefile in most directories—compile manually with g++ or clang++. Trap: File paths use inconsistent naming (spaces in directory names like Strassens algorithm, typos like Vaccum_Cleaner); expect quirks when scripting automated imports.

• Perfect Hashing (Cichelli's Algorithm) — Demonstrates compile-time hash function generation for static keyword sets; relevant for compiler design and high-performance string lookups in the Quark Search Engine backend.
• Strassen's Matrix Multiplication — Sub-cubic matrix multiplication algorithm reducing O(n³) to O(n^2.807); critical for large-scale linear algebra in AI/ML pipelines.
• Binary Search Variants (Ceiling, Floor, First/Last Occurrence) — Foundation for interval queries and range searches; essential for understanding how Quark and similar search engines index and retrieve data efficiently.
• Convolutional Autoencoders — Unsupervised feature learning technique using conv layers; powers OpenGenus Visual Project for image-based algorithm search.
• Transfer Learning (Inception, VGG Pre-trained Models) — Reusing pre-trained deep networks for new tasks with minimal data; enables the AI category's practical approach to computer vision without retraining from scratch.
• Bayesian Belief Networks — Probabilistic graphical models for reasoning under uncertainty; relevant for AI search ranking and knowledge representation in OpenGenus IQ.
• A* Search Algorithm — Informed heuristic search for pathfinding and optimization; foundational for game AI and route planning, complementing the classical search and graph categories.

• TheAlgorithms/Python — Competitor focused on Python implementations of classical algorithms; overlaps heavily with OpenGenus's Python tree but more narrowly scoped.
• TheAlgorithms/Java — Java-specific algorithm reference library; complements Cosmos for Java developers preparing for interviews.
• trekhleb/javascript-algorithms — JavaScript-focused algorithms and data structures with interactive visualizations; fills the gap for front-end developers in the OpenGenus ecosystem.
• donnemartin/system-design-primer — System design and architecture patterns that complement Cosmos's low-level algorithm focus; frequently used alongside Cosmos by interview candidates.
• OpenGenus/iq.opengenus.org — OpenGenus's interactive learning platform that consumes Cosmos code snippets as the source dataset for algorithm tutorials.

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add comprehensive test suite for algorithm_applications implementations

The repo contains numerous algorithm implementations (binary_search, bubble_sort, merge_arrays, etc.) across multiple languages but lacks unit tests. This is critical for a 'World's largest Contributor driven code dataset' since correctness is paramount. Adding tests would catch regressions and validate implementations across C++, Java, C, etc. implementations of the same algorithm.

• [ ] Create test/ directory structure mirroring code/algorithm_applications/src/
• [ ] Add unit tests for code/algorithm_applications/src/binary_search/ (test ceil, floor, first_and_last_position with edge cases)
• [ ] Add unit tests for code/algorithm_applications/src/bubble_sort/bubble_sort_implementation.cpp
• [ ] Add unit tests for code/algorithm_applications/src/merge_arrays/merge_two_arrays.c
• [ ] Set up CMake or language-specific test runners (pytest for Python, JUnit for Java, gtest for C++)
• [ ] Document test execution in CONTRIBUTING.md

Create language-specific CI workflows for algorithm validation

The .travis.yml exists but is minimal. The repo spans 8+ languages (C, C++, Java, JavaScript, Python, Go, Swift) with no per-language build/test validation. Adding GitHub Actions workflows to compile and test code in each language would catch syntax errors, compilation failures, and logic bugs before merge—essential for a dataset used in production (Quark Search Engine, OpenGenus IQ).

• [ ] Create .github/workflows/cpp-tests.yml to compile and test C++ files (code/algorithm_applications/src/*.cpp)
• [ ] Create .github/workflows/java-tests.yml to compile and run Java implementations (code/algorithm_applications/src/**/*.java)
• [ ] Create .github/workflows/python-tests.yml to validate Python code in code/artificial_intelligence/src/ with pytest
• [ ] Create .github/workflows/c-tests.yml for C files (code/algorithm_applications/src/**/*.c)
• [ ] Add status badges to README.md showing test pass/fail for each language

Add missing README.md files and standardize documentation structure in algorithm_applications subdirectories

While code/artificial_intelligence/src/ has README files (e.g., Inception_Pre-trained_Model/README.md, bernoulli_naive_bayes/README.md), the algorithm_applications subdirectories lack documentation. Implementations like 'Cichelli's Perfect Hashing Algorithm', 'Strassens algorithm', and 'binary_search' have no README explaining use cases, time/space complexity, or how to run the code—reducing discoverability and usability for new contributors.

• [ ] Create code/algorithm_applications/src/binary_search/README.md documenting all 3 binary search variants (ceil, floor, first_and_last_position) with complexity analysis and usage examples
• [ ] Create code/algorithm_applications/src/Cichelli's Perfect Hashing Alogorithm/README.md explaining the algorithm, complexity, and how to run Hashing.java with the provided data files
• [ ] Create code/algorithm_applications/src/Strassens algorithm/README.md with algorithm explanation and compilation instructions
• [ ] Create code/algorithm_applications/src/bubble_sort/README.md and code/algorithm_applications/src/merge_arrays/README.md following the same template
• [ ] Add a TEMPLATE.md in code/algorithm_applications/ as a reference for future contributors

• Add comprehensive unit tests for binary search variants in /code/algorithm_applications/src/binary_search/ using C++ Catch2 or Python unittest; currently no test files are visible for ceil, floor, or first/last position problems.: Improves code reliability, matches maintainers' explicit request for quality control, and benefits a high-traffic algorithm category.
• Create a /code/data_structures/linked_list/ directory structure with implementations in 5+ languages (C++, Python, Java, Go, Rust) for basic operations (insert, delete, traverse); aligns with README's mention of '50+ Linked List Problems' but implementations are not visible in file list.: Plugs a gap in foundational data structures that touches multiple languages and allows you to learn the repo's multi-language contribution workflow.
• Document the AI/ML category: add a top-level code/artificial_intelligence/README.md explaining how to run Inception, VGG-11, and autoencoder notebooks, including environment setup (PyTorch, TensorFlow versions, Python 3.7+ requirement), and fix typo in /code/artificial_intelligence/src/Vaccum_Cleaner/ (should be 'Vacuum').: Low-barrier contribution (documentation + typo fix) that improves onboarding and demonstrates caring for the AI/ML section.

The OpenGenus Cosmos repository is a collaborative algorithm and data structure collection with a generally acceptable security posture. The main concerns are low-severity issues: (1) potential sensitive data in committed CSV files used for ML training; (2) Jupyter notebooks that could contain unintended data exposure; (3) lack of documented security disclosure policies; and (4) outdated CI/CD configuration. There are no critical injection vulnerabilities, hardcoded secrets, or dependency files with known exploits detected. As this is an educational/reference codebase rather than a production system, the security score is reasonable. Recommendations focus on adding security governance documentation and modernizing the development workflow.

• Low · Potential Data Exposure in CSV Files — code/artificial_intelligence/src/*/**.csv files. Multiple CSV files found in the repository (e.g., dataset.csv, iris1.csv, Position_Salaries.csv, data_banknote_authentication.csv) that may contain sensitive or real-world data. If these contain actual personal information, they should not be committed to version control. Fix: Review CSV files for sensitive data. Use .gitignore to exclude data files or ensure only sanitized/synthetic datasets are committed. Consider using git-lfs for large data files.
• Low · Jupyter Notebook Files in Repository — code/artificial_intelligence/src/**/*.ipynb files. Multiple Jupyter notebook files (.ipynb) are tracked in version control. These files can contain sensitive outputs, API keys, or credentials in cell outputs that may be difficult to detect. They also contain binary serialized data that makes diffs harder to review. Fix: Consider using tools like nbstripout to remove sensitive outputs before committing. Add .ipynb files to .gitignore or establish a code review process specifically for notebooks. Document policies for handling notebooks in CONTRIBUTING.md.
• Low · Lack of Security Policy Documentation — .github/ directory. No SECURITY.md or security policy file is present in the repository. This makes it difficult for security researchers to responsibly disclose vulnerabilities. Fix: Create a SECURITY.md file following GitHub's security advisory guidelines at https://docs.github.com/en/code-security/getting-started/adding-a-security-policy-to-your-repository
• Low · Outdated CI/CD Configuration — .travis.yml. The repository uses .travis.yml for CI/CD, which indicates Travis CI integration. Travis CI's free tier was sunset in 2020. This may indicate the repository is not actively maintained with modern security scanning practices. Fix: Migrate to modern CI/CD platforms like GitHub Actions. Implement automated security scanning tools (SAST, dependency checks, secret scanning) in the CI/CD pipeline.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.