hero-landscape.png image file in the same folder to view the expressionist canvas.
Joulios is an AI Energy Decision Engine built around a unified computational model.
Connect project data, engineering models, simulations, and financial assumptions in one environment, then test scenarios, propagate changes, and optimize decisions before committing resources in the real world.
Teams rely on disconnected software, spreadsheets, consultants, engineering tools, and reports to evaluate projects. Technical analysis, economics, permitting, infrastructure constraints, and operational planning often exist in separate workflows.
This fragmentation slows development, increases costs, and makes it difficult to understand how decisions impact the system as a whole. This ultimately leading to a 77% failure rate inside transmission queue lines.
Why now
Energy demand and infrastructure complexity are rising faster than the disconnected workflows used to plan them. Faster development requires a system that can evaluate the whole project, not another isolated tool.
ChatGPT Image Jun 23, 2026 at 01_38_12 PM.png in the site folder to load the complete high-fidelity canvas painting.
Joulios connects technical, financial, geographic, environmental, and operational information in a Unified Model. Every calculation, simulation, and decision remains linked to the assumptions that produced it.
When an input changes, connected analyses update with it. Teams can build their own models, simulations, optimization routines, and workflows instead of forcing proprietary methods into a fixed software template.
The AI Engine operates on this connected model to configure analyses, automate repetitive work, interpret results, and help users explore complex systems with greater speed and consistency.
Joulios connects a Unified Model, a physics-based Simulation Engine, fast Surrogate Models, and an Optimization Engine inside one computational environment.
A connected computational graph that links data, models, tools, assumptions, and decisions while preserving every dependency.
A high-fidelity, Modelica-based physics engine for building, modifying, and running energy-system simulations directly in the workspace.
Create fast reduced-order models from high-fidelity simulation results so thousands of scenarios can be evaluated in seconds.
Explore thousands of design combinations across cost, performance, capacity, reliability, and other project objectives.
Gather evidence and requirements automatically.
Structure one credible Modelica solution topology.
Replay and compare later simulation runs.
Gaussian Processes map strict physical criteria with zero data custody overhead.
Matches coordinate structures mapped on scientific publishing index charts.
The same computational foundation can be applied across a wide range of energy planning, modeling, and system configurations.
*EXAMPLES, NOT PRODUCTS
Evaluate project opportunities and development constraints earlier in the process.
Understand how decisions affect project portfolios and development pipelines.
Explore how regulatory and policy changes influence technical and economic outcomes.
Test new technologies, system configurations, and operational strategies.
Create and evaluate digital representations of complex energy systems.
Writing from the Joulios team on energy development, simulation, modeling, and the ideas shaping the platform.
Most energy software solves one task at a time. Joulios connects the system, executes the analysis, and preserves the reasoning behind every result.
Engineering, economics, geography, constraints, and operations remain linked, so teams can understand how one decision changes the entire project.
Joulios can run and compare executable models rather than relying only on static reports or generated text.
Add custom models, equations, optimization routines, and engineering workflows without rebuilding your process around a closed application.
The AI Engine can configure analyses, identify missing inputs, automate workflows, and interpret results across the Unified Model.
Built with input from energy developers, engineers, researchers, and infrastructure organizations.
Deep dive into the operational mechanics, security standards, and local-first principles of Joulios.
No. Joulios is a high-performance, extensible engineering workbench built for complex physical simulations and optimizations. Unlike static planning platforms or dashboards that simply display historical map layers, Joulios features a browser-native physics solver that lets you build, simulate, and automate arbitrary physical workflows, including grid constraints, power flows, and thermal dynamics at the speed of modern software.
Joulios brings industrial-grade simulation directly into a standard web browser through WebAssembly (WASM). The platform compiles complex differential-algebraic equations (DAEs) from the Modelica Standard Library into a native browser-compatible binary (ssc-wasm). To execute heavy scenario sweeps without freezing your user interface, Joulios automatically offloads computations to a pool of background asynchronous Web Workers that process simulations in parallel across your machine's local CPU cores.
The entire Joulios workspace operates as an interconnected Directed Acyclic Graph (DAG) or "Task Tree." Every component in your project, whether it is an ArcGIS spatial dataset, a Modelica math model, a custom calculation script, or an AI agent state, exists as a navigable, typed node within this graph. Because the model is completely unified, dependencies are strictly tracked. If you tweak an upstream constraint (such as a substation capacity limit), all downstream dependent nodes instantly react and recalculate automatically.
Yes. FuncTasks are dynamic custom computation nodes configured with sandboxed JavaScript or compiled WebAssembly execution binaries. Developers write raw functions or import existing scripts directly inside individual code sheets, empowering teams to customize localized parameter controls, synthetic load-profile generators, or specific grid interconnection tariffs easily.
Joulios generates sample-efficient Gaussian Process Regression (GPR) surrogate models from complex physical inputs. By parsing weather conditions, PV Watts parameters, and geographical metrics, the system calculates posterior probability boundaries to estimate long-term thermal capacity layouts and electrical line load behaviors with minimal server overhead.
Joulios employs a coarse-to-fine hybrid execution loop directly inside the workflow engine:
Joulios is entirely Local-First. Because the Modelica physics engine, surrogate training algorithms, and optimization routines compile into native client-side WebAssembly and sandboxed containers, all heavy computing happens locally inside your browser memory. Your proprietary equations, private model parameters, and confidential datasets stay completely on your machine. They are never uploaded to a multi-tenant cloud "black box" vendor, ensuring you maintain 100% control and ownership of your intellectual property.
Yes, Joulios is architected precisely for the strict realities outlined in the 2026 NERC Critical Infrastructure Protection (CIP) Roadmap. NERC warns that relying on centralized, third-party cloud solutions and unencrypted public telecommunications networks exposes critical grid data to severe remote access vulnerabilities and state-sponsored routing exploits. By executing simulations locally via client-side WebAssembly, Joulios completely eliminates these external telecom and cloud-tenant attack vectors. Furthermore, our platform utilizes a strict schema validation engine (Zod) and fully reproducible builder environments (Nix/Yarn) to provide transparent configuration management, disciplined asset documentation, and secure identity mapping that aligns with NERC’s highest priority foundational cyber hygiene mandates.
Joulios handles Critical Energy Infrastructure Information (CEII) by inventing a zero-custody, local-first architecture, making it structurally impossible to leak your data. Because the simulation engine (ssc-wasm) and geospatial parsing tools run entirely inside your browser's local sandbox, your sensitive substation designs, one-line diagrams, and physical grid parameters never undergo network transfer. We do not own cloud servers or a centralized hosting backend; because your data never leaves your machine, you are structurally exempt from standard multi-party NDA gauntlets and background check bottlenecks.
We don't just rely on our offline design for safety; we back it up with strict client-side security measures to guarantee absolute trust:
With Joulios, you are completely safe from the risks of cloud network leakage. Your data remains fully inside your corporate perimeter, protected by both the walls of your own IT infrastructure and our programmatically enforced local isolation.
Create a connected model, test what changes, and find stronger decisions before capital is committed.
Feel free to contact us using the form below, or reach out directly via email at info@brgenergies.com.
Sign in to continue to your Joulios workspace.
By continuing, you agree to the Joulios Terms of Service and Privacy Policy.
Why the next generation of energy software must represent projects as executable systems rather than disconnected documents, models, and reports.
Share or save this article
Link copied to your clipboard.
The renewable energy industry has spent decades digitizing documents. We have digitized interconnection studies, environmental reports, financial models, permits, and engineering drawings. Every year, our industry creates more software, more data, and more reports. Yet despite all this apparent progress, renewable energy development remains a fundamentally fragmented process.
A single project routinely involves dozens of disconnected software applications, hundreds of isolated files, and thousands of decisions spread across a fractured ecosystem of consultants, engineers, developers, regulators, utilities, and financial institutions. The systemic result is an industry that spends far more time manually moving information between isolated silos than actually understanding the overarching system it is trying to build.
This data-routing friction is no longer just an administrative annoyance. It is actively constraining the development of new energy infrastructure.
According to data compiled by Lawrence Berkeley National Laboratory, 10,300 projects are actively sitting in U.S. interconnection queues, representing 2,290 GW of total capacity, more than the entire operating generation fleet of the United States. Energy storage alone accounts for nearly 39 percent, or roughly 890 GW, of that capacity.
The paperwork bottleneck has fundamentally altered project lifecycles. The median time between an initial interconnection request and commercial operation has risen to 55 months, more than double the timelines seen a decade ago.
Developers are forced to make layout, equipment, and financial decisions long before receiving final grid impact results. The capital risk is severe. Over the last two decades, 77 percent of all project capacity that entered the queue ultimately withdrew.
As projects grow larger, regulations grow tighter, and power grids become more congested, the primary challenge is no longer gathering information. The challenge is understanding relationships. Navigating those relationships requires a different computational foundation.
A renewable energy project is not an interconnection study. It is not a permit, a financial model, or a site assessment. Those are static descriptions of a project at a particular point in time.
The project itself is the dynamic web of relationships between those documents.
A change in land constraints alters the physical project layout. The layout changes energy production curves. Production determines wholesale revenue. Revenue changes debt sizing inside the financial model. Financing parameters ultimately determine project viability. Every node influences other nodes.
Legacy software treats these dependent activities as separate workflows. The industry has become exceptionally good at producing documents that describe past realities. At BRG Energies, we believe the next step is software that can represent and execute the system itself.
We believe a renewable energy project should be represented as an executable system rather than a disconnected portfolio of PDFs and spreadsheets. This conviction led us to build the Unified Model.
The Unified Model is not a database, a project management dashboard, or a compliance tracker. It is a live computational representation of the project itself, structured as a directed graph.
The Joulios Unified Model
Upstream changes cascade through every dependent part of the project.
Every element of a development pipeline, including geospatial datasets, engineering workflows, financial tools, AI agents, and human design inputs, exists as a node within one connected graph.
Because dependencies are explicit, the graph becomes executable. When a user alters an upstream variable, every dependent node can evaluate and respond. Instead of an engineer manually translating layout adjustments into a performance model and then copying those results into a finance spreadsheet, the impacts propagate through the system.
The graph becomes the project. Every execution is versioned and tracked, creating an auditable history of how each design iteration evolved.
Once a project is mapped onto a computational graph, nodes do more than store static data. They execute logic. A node can run a multi-variable physics simulation, process a large geospatial dataset, evaluate a pro forma financial model, invoke an optimization routine, or trigger an AI workflow.
Instead of engineers passing raw data between isolated tools, the project itself becomes the computational environment. Traditional software stores project information. The Unified Model stores project intelligence.
There is a difficult engineering challenge at the center of this vision: reality is computationally expensive.
Renewable energy projects involve complex interactions between electrical infrastructure, thermal dynamics, equipment degradation, and changing market conditions. To model these interactions with engineering confidence, Joulios uses Modelica, an advanced modeling language designed to simulate complex physical systems.
A high-fidelity simulation that takes thirty seconds is reasonable for one evaluation. It becomes impractical when the goal is to run hundreds of thousands of multi-variable iterations and identify the best project configuration. Exploring uncertainty under development deadlines becomes computationally constrained.
To overcome this limitation without abandoning engineering accuracy, Joulios introduces a second layer: Surrogate Models.
A surrogate model is a highly optimized computational approximation of a complex system. Its purpose is not to replace physics, but to scale it. Joulios generates surrogates from the high-fidelity simulations, datasets, and workflows tied to the Unified Model. Whether they are reduced-order mathematical models or neural approximations, their goal is the same: preserve the system behavior that matters while reducing evaluation time from minutes to milliseconds.
The Hybrid Simulation Workflow
Surrogates are first-class nodes within the Unified Model. Each one carries versioning, operational boundaries, validation history, and known error tolerances. It becomes a reusable piece of the project's computational memory.
The standard critique of surrogate modeling is that it trades precision for speed. We agree, which is why Joulios uses a Hybrid Execution architecture that balances approximation with physical validation.
During early exploration, surrogate models provide the speed required to test thousands of equipment configurations, battery sizing options, and layout variations. When the system identifies a promising configuration and engineering certainty becomes critical, execution returns to the underlying high-fidelity physics model for verification.
The workflow is simple: Physics Model, Surrogate Approximation, Large-Scale Exploration, Final Physics Validation. Developers no longer have to choose between moving quickly and being correct.
When projects are anchored by a Unified Model and accelerated by surrogates, large-scale simulation becomes a core capability.
Simulation is not about finding one perfect answer. It is about exploring possible futures. Developers face volatile merchant power prices, changing tax credit frameworks, equipment lead times, and uncertain network upgrade costs. NREL cost benchmarks indicate that non-hardware soft costs can consume 50 percent to 65 percent of total capital expenditures for utility-scale solar. Much of the financial risk lives in the pre-construction phase.
Traditionally, evaluating these risks required heavy, isolated desktop software for grid, thermal, or operational modeling. These tools sit apart from modern collaborative workflows. Building custom simulations or running large scenario sweeps often requires sending code and data to expensive vendor-controlled cloud infrastructure.
Joulios changes this model by bringing a complete compilation and solver toolchain into the web browser through a native WebAssembly compilation layer.
The Client-Side Simulation Engine
Instead of sending proprietary design data to a remote server, developers can build, compile, and execute custom physical simulations in the browser. A stateless solver runs inside background Web Worker pools scaled to local CPU hardware. Parameters stream directly to those workers, allowing thousands of scenarios to execute in parallel without locking the interface.
Because the compiler and solver operate client-side, engineers can benchmark hardware layouts, stress-test uncertain futures, and run high-fidelity simulations on their own machines with no required cloud execution layer and strong data privacy.
If simulation helps us understand what could happen, optimization helps determine what we should do.
Joulios uses Bayesian Optimization to navigate large engineering design spaces. Rather than evaluating every mathematical combination sequentially, Bayesian algorithms learn from each iteration and direct the search toward more promising design variations.
Procedural generation and algorithmic design reduce the search space before optimization begins. The system evaluates hard boundaries such as:
By removing physically impossible or non-permittable layouts before optimization begins, Joulios focuses its computational effort on feasible solutions.
The Joulios Optimization Pipeline
As engineering software becomes more intelligent, developers must confront a critical question: who owns the underlying asset intelligence, and how easily can it interface with the real world?
Most enterprise platforms centralize data and lock up knowledge. Models live in vendor-controlled cloud environments, raw data is uploaded to remote infrastructure, and core engineering expertise becomes dependent on an external platform's survival and pricing.
Joulios is designed around a local-first philosophy. Project graphs remain under customer control, and physics models remain portable.
Developers also operate within strict regulatory systems. Regional transmission authorities, regulatory commissions, and financing institutions require technical data in specific legacy formats.
Regulatory Compliance Pipeline
Joulios is intended to make the computational project graph exportable into industry-standard formats. Whether a team needs native files for power flow and interconnection analysis or specialized formats for financial review, the platform bridges next-generation simulation with existing infrastructure requirements.
Proprietary engineering insights should not be trapped inside someone else's database. They should also remain compatible with the agencies and organizations that approve a project. Joulios is designed for privacy, data permanence, portability, and customer control.
The last twenty years of energy software focused on digitizing documents. The next twenty years will be about digitizing the relationships between them.
The era of developing system-critical infrastructure through disconnected PDFs, static spreadsheets, and fragmented engineering tools is drawing to a close. Energy projects must become native, executable computational environments.
By unifying relationships, enabling custom simulations to run locally in the browser, accelerating physics through surrogate models, and optimizing within regulatory and physical constraints, Joulios provides a modern computational foundation for building the future of the grid.