DEV Community: Krishna Kotikalapudi

I built GridLens: a power system study tool that finds the outage your base-case load flow misses

Krishna Kotikalapudi — Sun, 18 Oct 2026 19:38:39 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

GridLens is a browser-based power system analysis tool. You enter a grid as two editable tables (bus data and line data) or upload a CSV. One click on Solve runs a full study suite and shows the results in tabs:

Tab	What it does
Load flow	Bus voltages, angles and injections, per-line P/Q flows and losses, a voltage profile checked against 0.95 / 1.10 pu limits, and a Newton-Raphson convergence plot
Network diagram	The grid drawn as a graph. Bus voltages are labelled, line thickness scales with MW flow, and arrows show power direction
Method comparison	The same case run through Newton-Raphson, Fast Decoupled and Gauss-Seidel
N-1 contingency	Every line is removed in turn, the case is re-solved, and outages are ranked worst first
Export	CSVs of bus results, line flows, N-1 results and the fault table, a `figures.zip` PNG bundle, and the current input tables

A short-circuit study and an AI-written report (a local open-weight model summarises the results in plain English) sit alongside these, and each can be toggled on or off in the sidebar. A summary strip under the Solve button shows convergence status, slack power, total generation and load, losses (as MW and % of load), and min/max voltage with the bus where each occurs. A red N-1 violations badge appears when a contingency breaks limits.

Inputs are plain per-unit tables.

Bus table: Type (Slack / PV / PQ), V setpoint or start guess, Pg, Qg, Pd, Qd.
Line table: From, To, R, X and total line-charging B, split B/2 at each end.

Other features: Quick / Standard / Advanced modes, a preset case dropdown, downloadable CSV templates, a dark theme, and a help tooltip on every control.

Who would pay: small power consultancies, solar and microgrid installers, and industrial plant engineers who need quick feasibility and contingency checks but can't justify a commercial license. University power-systems labs are a second market.

Problem it solves: commercial tools are expensive and heavy. Free scripts give you matrices and no interpretation. GridLens gives you the solve, the safety check and the explanation in one place.

A result that shows why N-1 matters

On the built-in 5-bus demo, the base case looks healthy: it converges, min voltage is 1.011 pu at bus 5, and losses are 4.6 MW (2.8% of the 165 MW load). But the N-1 study shows that losing line 2-5 drops bus 5 to 0.8975 pu, well below the 0.95 limit. It's the only outage that causes a violation, and a base-case solve alone would never show it.

The ranking also separates two kinds of "worst". Losing line 1-2 causes no voltage violation, but losses jump to 0.1667 pu (16.7 MW), about 3.6 times the base case. GridLens shows both views, so you can tell which outages threaten voltage and which are just expensive to run.

Demo

📹 Watch the GridLens demo

Walkthrough of the 5-bus demo case (base 100 MVA):

Setup: bus 1 is the slack at 1.06 pu, bus 2 is a PV bus at 1.04 pu with 0.4 pu generation and 0.2 + j0.1 pu load, and buses 3, 4 and 5 are PQ load buses (0.45, 0.40 and 0.60 pu real power). There are 7 lines.
Solve: Newton-Raphson converges in 3 iterations at tol 1e-8. The slack supplies 129.6 MW, bus 2 supplies 40 MW, total generation is 169.6 MW against 165.0 MW of load, so losses are 4.6 MW.
Bus results: voltage falls smoothly from 1.060 pu at bus 1 to 1.011 pu at bus 5, with the angle reaching −6.09° at bus 5.
Line flows: the heaviest corridor is 1→2 at about 89 MW, followed by 2→5 at 55 MW. Both ends of every line are reported, so you can see the loss per line.
Convergence: the max mismatch drops below 1e-8 in three steps, the quadratic convergence Newton-Raphson should show.
Network diagram: bus voltages on the nodes, MW flows on the lines, and arrows showing direction. Line 4-5 carries only 6 MW, because that part of the grid is nearly balanced.
Method comparison: all three solvers land on the same answer.

Method	Converged	Iterations	Loss (MW)	Min V (pu)
Newton-Raphson	✅	3	4.6289	1.0107
Fast Decoupled	✅	7	4.6289	1.0107
Gauss-Seidel	✅	43	4.6287	1.0107

Gauss-Seidel needs 43 iterations to NR's 3. Its loss differs in the fourth decimal because it uses its own, looser default tolerance.

N-1: the ranked outage table described above.
Export: every table and figure can be downloaded for reports.

Code

haki-overflow / GridLens

CAPSA — Power System Analysis

A Python tool that solves an N-bus power system and turns the results into something readable: load flow by three classical methods, an N-1 contingency sweep, a three-phase fault study, and plots plus a plain-English summary. It was built for Hacktoberfest and uses only open-source libraries and open-weight models: the solver does every calculation, and a local Gemma model served by LM Studio only explains the numbers it is given.

Features

Three load flow methods: Newton-Raphson, Fast Decoupled (XB), Gauss-Seidel.
Two editable presets: 5-bus demo and IEEE 14-bus.
N-1 contingency sweep: each line removed in turn, case re-solved, ranked worst-first.
Three-phase fault analysis at every bus via the Zbus matrix.
Network diagram coloured by bus voltage, plus voltage-profile and post-fault charts.
Method comparison table (convergence, iterations, loss, minimum voltage).
Optional report written by a local Gemma model via LM Studio, given only the solver's numbers.

…

View on GitHub

How I Built It

App layer: Python and Streamlit. The bus and line tables are editable data grids, so users can change a load or a line impedance and re-solve immediately.

Numerics: the three load-flow methods are implemented from scratch: Newton-Raphson, Fast Decoupled and Gauss-Seidel. Each one reports convergence status and iteration count, so the method comparison is honest. The N-1 study re-runs the Newton-Raphson solver once per line outage and ranks the results by number of violations, then by minimum voltage. The short-circuit module produces the fault table.

Plots: Matplotlib for the voltage profile with limit lines, the log-scale convergence history, and the flow-weighted network diagram. All figures can be bundled into a zip.

Open-source AI: the report is written by Gemma running locally through LM Studio. After a solve, GridLens passes the numerical results to the model (convergence, losses, voltage extremes, the N-1 ranking, the fault table), and the model writes an engineer-readable summary. The numbers come from the solvers and the model only does the explaining, so it can't invent results.

Dev workflow: built with opencode, with a project-context file so the agent kept the architecture in mind between sessions. The code is split into separate modules (solvers, contingency, short circuit, plotting, report) to keep it easy to debug.

Why Does Open Innovation Matter?

Network models are sensitive. Utilities and industrial plants usually can't send grid topology and load data to a third-party API. Because the report model is open-weight and runs locally, the AI feature works on confidential data, offline, with no per-token cost.

A closed API would have blocked the people most likely to pay: the privacy problem rules out the customers, and per-call pricing makes a cheap side-hustle tier hard to offer. With open weights, anyone can also swap in a different model or adapt one to their own reporting style, without waiting for a vendor.

The same idea applies to the solvers: the code is open, so an engineer can read exactly how Newton-Raphson and the contingency ranking are computed and verify it against a textbook. That matters in a field where you have to trust the numbers.

I built a weekly recap of the Premier League for a friend.

Krishna Kotikalapudi — Mon, 05 Oct 2026 05:55:52 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

My friend is a die-hard Arsenal fan. Between early classes, late labs, and a hectic FSAE Formula Student workload, he prefers to listen to what happened in the Premier League over the weekend.

He prefers to listen en route to classes, so I built TheGoonerBriefing: a weekly matchday recap made for the walk to class. It pulls the latest Premier League results, turns them into a conversational script, and reads it out loud as a 2.5-minute audio file. That's roughly one walk to class, or one very optimistic bus ride, and he can play it without looking at his phone.

Demo

🎧 Listen to a sample briefing

(Headphones recommended. Playing it in a lecture hall is between you and your conscience.)

Code

haki-overflow / TheGoonerBriefing

View on GitHub

How I Built It

The pipeline has three steps, and none of them involve me typing "so, anyway, Arsenal drew" into a voice memo:

Data: Results, scorers and red cards come from the free Fantasy Premier League API, the one that powers the FPL site. It needs no account or API key. Plain Python picks out Arsenal's result, any hat-tricks or red cards, and their next fixture, then saves it all as one facts.json file. So the scores are real, and not whatever the group chat remembers.
Script: Gemma (gemma-4-12b-qat) turns the raw match data into a recap written the way people actually talk. It has all the confidence of a Twitter keyboard warrior, but with the facts to back it up.
Voice: Kokoro, an open-weight text-to-speech model, reads the script aloud. It's no Peter Drury, so don't expect poetry about a 0-0 draw, but it is free and shows up every Monday.

I started with a user base of exactly one, which is the only audience guaranteed to text me back. It also meant real feedback from a real person: I could tweak the length, tone, and pace after each listen, which is what "build for a friend" is really about.

Where it is today: v1 is run manually, which is a fancy way of saying "I press the button." The next step is a weekly GitHub Action or cron job so the briefing is ready every Monday without me. Until then, I am the scheduler, and I accept no complaints about uptime.

Where it could go: the pipeline doesn't actually care that it's football. Data goes in, Gemma turns it into a spoken script, and Kokoro reads it out. Swap the data source and the same setup works for:

Premier League: the full league, not just Arsenal
Other football: European leagues and cup competitions
Other sports: cricket, F1, tennis
News: a short morning headline briefing for anyone with a commute

If it works for one friend, the rest is just new data sources.

Why Does Open Innovation Matter?

I wanted TheGoonerBriefing to be something that keeps working long after the weekend is over. Open models make that possible. Gemma writes the script and Kokoro speaks it, with no per-request billing, and the whole thing can keep running for as long as he keeps showing up to class.

A choice I actually had to make

For the voice, I seriously considered ElevenLabs. Their voices are excellent, and the free months on offer made it tempting. I went with Kokoro for two reasons that came from this specific project:

The challenge is about open-source AI at the core. Kokoro is open-weight, so the voice layer fits that brief instead of sitting outside it.
It's a gift, so it should keep working. I'm not planning to maintain a subscription on his behalf, and I'd rather hand him a pipeline he can run himself.

Both tools are good at what they're built for, and for a weekly personal project that someone else can fork and own, open-weight won out. And since the code is open, he can fork it, change the length and tone to whatever suits his mornings. It's his briefing now, not mine.

Prize Categories

Best Use of Gemma: Gemma (gemma-4-12b-qat) is the brain of the operation. It turns raw match data into a spoken recap, and without it the briefing would just be Kokoro reading out a JSON file.