1. Introduction
2. Who Should Use EveryO
3. System Requirements
4. Prepare Your Environment
5. Install EveryO
6. Verify Your Installation
7. Explore Your First Python Session
8. Optional Dependencies and Backends
9. Development Environment
10. Testing and Validation
11. Command-Line Tools
12. Troubleshooting
13. Learning Path
14. Contribution Workflow
15. Support and Resources
16. Next Steps

EveryO is an open-source Python framework for machine learning and deep learning development.

It provides foundational components for numerical computation, automatic differentiation, neural network construction, training, and experimentation.

The framework uses NumPy as a foundational computation backend and includes optional integrations for additional computational capabilities.

By the end of this guide, you should be able to:

• Prepare a Python development environment.
• Obtain the EveryO source code.
• Install the framework.
• Verify the package installation.
• Explore the command-line interface.
• Locate examples and documentation.
• Run the project's tests.
• Understand how to continue learning.

EveryO is intended for people interested in developing or studying machine learning systems.

Explore tensor operations, neural network implementations, and training utilities.

Experiment with computational workflows and investigate framework behavior.

Study the fundamentals of machine learning frameworks and automatic differentiation.

Contribute to framework implementation, documentation, testing, and developer tooling.

Development may be performed in compatible Python environments on:

• Windows.
• Linux.
• macOS.

Platform-specific functionality, particularly CUDA acceleration, depends on compatible hardware and software.

Not every combination of operating system, Python version, and optional backend is guaranteed to have been tested.

Consider using:

• A supported Python interpreter.
• Git.
• A terminal.
• A code editor or IDE.
• A Python virtual environment.

Popular editor choices include Visual Studio Code and PyCharm, although neither is required.

Open your terminal and run:

python --version

On systems where Python is invoked as python3:

python3 --version

Ensure that the installed Python version is 3.9 or newer.

python -m pip --version

git --version

If Git is unavailable, install it from:

https://git-scm.com/

Choose a location for your development projects.

Example:

mkdir everyo-workspace
cd everyo-workspace

git clone https://github.com/krishanth7/EveryO.git
cd EveryO

This downloads the EveryO source repository.

Using a dedicated virtual environment is recommended.

python -m venv .venv

Activate it in PowerShell:

.\.venv\Scripts\Activate.ps1

python3 -m venv .venv
source .venv/bin/activate

python --version
python -m pip --version

The active Python interpreter should correspond to your intended environment.

python -m pip install --upgrade pip setuptools wheel

This step is recommended for development setup but may be unnecessary in managed environments.

From the repository root:

python -m pip install -e .

This installs EveryO in editable mode.

Editable installation is useful for contributors because source changes can be reflected without repeatedly reinstalling the project.

To install the project's development dependencies:

python -m pip install -e ".[dev]"

Development dependencies include tools used for testing, linting, and related engineering workflows.

Run:

python -m pip show everyo

You should see installed package metadata, including the package name and version.

Run:

python -c "import everyo; print('EveryO import successful')"

If the import succeeds, the package is available to the active Python interpreter.

EveryO includes command-line utilities for inspecting and diagnosing the environment.

everyo info

Use this command to inspect framework information exposed by the installed version.

everyo doctor

This command is intended to help diagnose installation and environment configuration.

everyo --help

Use the CLI help output to inspect available commands and options.

• Python version meets the minimum requirement.
• Virtual environment is active, if used.
• Package installation completed.
• import everyo succeeds.
• everyo info executes.
• everyo doctor executes.
• CLI help is accessible.

From the activated environment:

python

Inside the Python interpreter:

import everyo

print("EveryO is available.")

This confirms that Python can import the installed package.

For an introductory inspection:

import everyo

public_names = [
    name for name in dir(everyo)
    if not name.startswith("_")
]

print(public_names)

This displays public-looking names exposed by the installed top-level package.

Not every displayed name is necessarily a documented stable API.

The EveryO repository includes an examples/ directory.

Browse the available examples:

EveryO Examples

Select an example that matches your installed dependencies and current learning objectives.

Read its requirements and instructions before execution.

Start with:

1. Tensor creation and shapes.
2. Mathematical operations.
3. Broadcasting.
4. Automatic differentiation.
5. Neural network layers.
6. Loss functions.
7. Optimizers.
8. Model training.

For exact Python API signatures and supported parameters, refer to the source code and version-specific documentation.

EveryO provides optional dependency groups for additional capabilities.

Install the TensorFlow extra:

python -m pip install -e ".[tensorflow]"

Actual compatibility depends on the Python version, platform, and TensorFlow distribution.

Install the ONNX extra:

python -m pip install -e ".[onnx]"

This installs the project's declared optional dependencies for supported ONNX functionality.

python -m pip install -e ".[yaml]"

python -m pip install -e ".[cuda]"

The EveryO repository includes the following major areas:

EveryO/
├── .github/
│   └── workflows/
├── everyo/
├── tests/
├── docs/
├── examples/
├── benchmarks/
├── configs/
├── cuda/
├── README.md
├── CHANGELOG.md
├── CONTRIBUTING.md
├── SECURITY.md
├── LICENSE
└── pyproject.toml

Contributors should prioritize:

• Clear code organization.
• Maintainable interfaces.
• Reproducible tests.
• Consistent documentation.
• Meaningful error messages.
• Explicit dependency requirements.
• Responsible performance claims.

python -m pip install -e ".[dev]"

python -m pytest

Example:

python -m pytest tests/test_tensor.py

ruff check .

ruff format --check .

Some tests may be skipped or require optional software or hardware.

A successful CPU test run does not establish correctness of CUDA-specific operations.

Test results should be reported with:

• Environment.
• Python version.
• Dependencies.
• Test command.
• Passed tests.
• Failed tests.
• Skipped tests.

EveryO exposes a CLI entry point named everyo.

Run:

everyo --help

For command-specific options:

everyo benchmark --help

• Review command help before execution.
• Use a dedicated development environment.
• Preserve error output when reporting failures.
• Avoid assuming optional dependencies are installed.
• Verify benchmark configurations before comparing results.

python -m pip install -e .
python -m pip show everyo

python -m pip install -e ".[onnx]"

Goal: Understand the basic framework environment.

Topics:

• Installation.
• Python imports.
• Tensor fundamentals.
• Numerical operations.

Goal: Understand gradient-based computation.

Topics:

• Computational graphs.
• Gradients.
• Backpropagation.
• Differentiable operations.

Goal: Build and train models.

Topics:

• Layers.
• Activation functions.
• Loss functions.
• Optimizers.
• Training workflows.

Goal: Explore advanced framework features.

Topics:

• Attention.
• Transformers.
• Quantization.
• ONNX export.
• Profiling.
• Distributed training.

Goal: Understand and contribute to EveryO internals.

Topics:

• Framework architecture.
• Backend integration.
• Testing.
• Performance.
• Documentation.
• Contribution workflows.

EveryO welcomes contributions from the open-source community.

Read:

• Contribution Guidelines
• Code of Conduct
• Governance

Review an Issue
      |
      v
Prepare Development Environment
      |
      v
Create a Working Branch
      |
      v
Implement Changes
      |
      v
Run Tests and Quality Checks
      |
      v
Submit Pull Request
      |
      v
Review and Feedback
      |
      v
Approval and Merge

Contributions should be:

• Clearly scoped.
• Documented.
• Tested where appropriate.
• Compatible with project guidelines.
• Reviewed before merging.

When reporting a technical issue, include:

1. EveryO version.
2. Python version.
3. Operating system.
4. Installation method.
5. Relevant dependencies.
6. Steps to reproduce.
7. Expected behavior.
8. Actual behavior.
9. Relevant error messages.

Do not publish credentials or other sensitive information in public reports.

Congratulations on preparing your EveryO development environment.

You can now continue with the following topics: