《▓ Quantified API ▓》

Quantified API is a high-performance Minecraft modding framework designed to offload heavy computations, prevent lag, and make your mods scale efficiently across modern hardware. It is actively maintained and updated, with bug fixes, new features, and optimizations coming regularly.

💡 Recommendation: If you are developing mods that push Minecraft’s limits (world-gen, AI, networking, large datasets), using Quantified API is highly recommended to keep your game stable and performant.

《 Core Features 》

• Smart task routing and dynamic scheduling for optimal CPU/GPU utilization
• Multi-tier caching: RAM, disk, VRAM support
• Asynchronous and parallel execution with thread-safety and isolation
• Optional GPU acceleration via OpenCL
• Networking for distributed jobs across servers
• Built-in diagnostics, performance metrics, and telemetry
• Lightweight, local webpanel for monitoring and configuration
• Easy integration into your mods with minimal code changes
• Scalable architecture for modpacks of any size

《 How It Works 》

Quantified API analyzes submitted jobs and routes them efficiently:

• Small jobs run on lightweight CPU pools
• Parallel jobs are split across multiple CPU cores
• GPU-eligible tasks are offloaded to OpenCL devices
• Networking handles multi-instance/server coordination

Automatic caching, multithreading, GPU fallback, and network execution ensure your mods stay smooth and responsive.

《 Webpanel 》

Quantified API includes a local webpanel that allows:

• Real-time job execution monitoring
• Cache performance insights
• System health diagnostics
• Configuration of API parameters

Runs locally with zero internet requirement. Perfect for mod developers wanting live insights.It is disabled by default, and can be enabled in the config file, found at `Config/Quantified/quantified_config.json`

《 Quick Examples 》

Simple async task:

// Submit a task asynchronously CompletableFuture<String> result = QuantifiedAPI.submit("myTask", () -> { return "done"; });

Parallel workload:

ParallelCompute.builder("mymod", "chunkPrefetch", taskId) .slices(() -> buildSlices()) .sliceExecutor(slice -> processSlice(slice)) .reducer(results -> combine(results)) .maxParallelism(Runtime.getRuntime().availableProcessors()) .submit();

GPU/OpenCL tasks:

QuantifiedOpenCL.builder("mymod", "gpu-raytrace", taskKey) .workload(context -> runKernel(context)) .cpuFallback(() -> fallback()) .complexity(QuantifiedOpenCL.Complexity.COMPLEX) .submit();

《 Why You Should Use This API 》

• Prevents mods from freezing or crashing Minecraft
• Handles heavy computations efficiently
• Leverages CPU and GPU parallelism
• Provides telemetry and performance monitoring
• Supports large modpacks and distributed servers

💡 Recommendation: Integrate Quantified API to modernize your mod architecture and keep your game smooth even under heavy loads.

《 Licensing & Contributions 》

Licensed under BRSSLA V1.3. Free for personal and commercial mod use with attribution. Large-scale or commercial modpacks/mods should contact BlackRift Studios.

All contributions, bug fixes, examples, and feature requests on GitHub are greatly appreciated. Community involvement helps the API evolve and improve constantly.

Supported modpacks and developers can rely on active updates, improvements, and ongoing guidance.

This project is actively supported and receives frequent updates. If you want your mods to stay stable, scalable, and future-proof, I strongly recommend using Quantified API as your foundation.

Quantified API - Developed by Admany - BlackRift Studios - December 21, 2025