Release Notes

• View → Show Results (Ctrl+R) hides the results so the editor fills the window; press it again, or run the query, to bring them back.
• View → Show Sidebar (Shift+F8) hides the sidebar. ByteRunner remembers your choice.
• View → Auto Scroll Results keeps the newest result in view while a query runs, for a loop that dumps as it goes.
• Query → Cancel and Run (Ctrl+Shift+F5) stops the running query and starts it again.
• Edit → Paste as Escaped String (Ctrl+Shift+V) pastes the clipboard as a string literal for the query's language: a Windows path, a JSON sample or several lines of text come in with the quotes, backslashes and line breaks escaped. In Kotlin a $ is escaped too, so it isn't read as a template.
• Edit → Copy for Markdown copies the selection, or the whole query, as a fenced code block that GitHub, Slack and most chat tools highlight.
• File → Revert to Saved throws away your changes since the last save, after asking.
• File → Show in Explorer (Show in Folder on Linux) opens the query's folder.

All of them are in the command palette (Ctrl+Shift+P) too.

ByteRunner now fits more code and more results on the screen. The bars above the editor take about half the room they did, so your query starts about 80 pixels higher. Menus, the sidebar, the tabs and the result grids are all tighter, and the Navigate menu is half its old height.

• The tabs and the toolbar now sit over the editor, and the sidebar runs the full height of the window.
• The bar that said "Query" over the editor is gone. The count of a query's imports and packages is now in the status bar; click it to open Query Properties.
• Each connection takes one line in the sidebar. A connection to a file, such as a SQLite database, shows the file's path when you hover over it.

Everything is where it was in the menus, and every button is still at least 24 pixels across.

Press F12, or Ctrl+click a name, to jump to where it's declared: a variable, a function, a class, a parameter, or a property. For person.name, the compiler works out what person is, so you land on the name of the right class even when two classes have one. A name from a library says where it comes from instead.

The new Navigate menu also has:

• Back and Forward (Alt+Left, Alt+Right, or the mouse's back and forward buttons) to retrace your jumps, across tabs.
• Go to Last Edit (Ctrl+Shift+Backspace).
• Go to Member (Alt+\): a list of the query's classes, functions and properties. Type part of a name to narrow it.
• Go to Next Error and Go to Previous Error (Ctrl+Shift+F12, Ctrl+Shift+F11), which select each red underline in turn and show its message.
• Go to Previous Method and Go to Next Method (Ctrl+Shift+comma, Ctrl+Shift+period).
• Go to Matching Bracket (Ctrl+]).
• Go to Line (Ctrl+G), which has moved here from the Edit menu.

Switching tabs from the keyboard

Ctrl+Tab goes back to the tab you used last. Hold Ctrl and press Tab again to go further back, and add Shift to go the other way. Ctrl+PgUp and Ctrl+PgDn go to the previous and next tab, and Go to Tab (Alt+Shift+W) lists every open tab by name. Each tab now keeps its place: switching back puts the cursor where you left it, rather than at the top.

Update now could still say the download didn't match its fingerprint. The installer is large, and the download server often ends the connection before all of it has arrived. Now each time the connection drops, ByteRunner picks the download up where it stopped, rather than starting again, and keeps going until it has the whole file. Nothing is installed from a partial download, and the finished file is still checked against its fingerprint and signature.

This takes effect for updates made *from* 1.0.95 onward. If Update now on an earlier version reports a fingerprint mismatch, click it again, or download and run the installer by hand.

In Kotlin and Java queries, rest the mouse on a name and its type appears: a property (age: Int), a variable where it's used or declared (oldest: Person), a lambda's parameter, what a call returns (listOf(...): List<Person>), and a database column (username: Column<String>). The type comes from the same compiler that runs the query. An error underline still shows its message.

Updates survive a dropped connection

If the update download was cut short (Wi-Fi dropping, say), Update now said the download didn't match its fingerprint. It now tries the download once more by itself, and if that is cut short too, says the download was interrupted, so you know to try again. Nothing is installed from a partial download.

Tools → Import Connections… now finds the servers you registered in SQL Server Management Studio 17 through 22 (and older versions), with their folders. Before, it found none from those versions. Analysis Services and other non-database servers, and servers that sign in with Microsoft Entra ID, are listed with the reason they can't be imported.

Choose what to import

Each tool's connections have their own section, with one tick to take all of them, or none, and a tick for each connection. Each section says which file it read, or where it looked if it found nothing. A server saved in more than one tool is offered from each and imported once.

SQLite database files saved in other query tools now import as SQLite connections, and so do their SQL Server, PostgreSQL and MySQL connections made through Entity Framework Core.

Installing ByteRunner on Linux now gives you the byterunner terminal command, already on your PATH: byterunner run report.brpad runs a saved query in the terminal, prints its output, and exits non-zero if it fails, so it fits in shell scripts and cron jobs. Uninstalling removes it.

• Ctrl+N and Ctrl+O now work on the Welcome screen, which shows them on its cards; before, they did nothing until a query was open. File → New Query from the Welcome screen now opens the query too, as does Ctrl+T, and Ctrl+Shift+P opens the command palette from anywhere.
• After New Query, you can start typing straight away: the editor has the keyboard.
• F5 runs the query wherever you are in the window, not only while the editor has focus.

These turned up in ByteRunner's new Linux tests, which install it on Ubuntu 24.04, Ubuntu 22.04 and Debian 12 and use it by keyboard; the same bugs were in the Windows version, now fixed in both.

After a dot, typing the start of a name now narrows the suggestions to the ones that match. Before, the list showed after it. but the first letter you typed (it.v) emptied it and closed it. Suggestions also show what each one really gives you: value on a map entry of numbers says Int, first() on a list of strings says String, where they used to say Object.

ByteRunner now runs on Linux. Download the .deb from byterunner.dev and install it with sudo apt install ./byterunner_1.0.89_amd64.deb on Debian, Ubuntu and their derivatives (64-bit). It bundles its own Java runtime, like the Windows version, and finds itself in your applications menu under Development. When a new version is out, ByteRunner tells you and opens the download page.

The terminal command for enterprise installs

The MSI now takes ADDTOPATH=1: msiexec /i ByteRunner-1.0.89.msi ADDTOPATH=1 puts the byterunner command on the PATH for everyone on the PC, and uninstalling takes it off again. Without it, the PATH is left alone, and anyone can still turn the command on for themselves in Preferences → Terminal.

Smaller fixes

• byterunner run no longer prints "No output produced" under what your script printed.
• Saving a connection now closes its old connections straight away, everywhere ByteRunner had one open, so nothing goes on using the old settings.
• If an update fails to download, ByteRunner's log now says why.

With the dark theme on and Windows set to light, every dialog (Preferences, the update screen, the file chooser and the rest) had a white title bar over a dark window. Now every window ByteRunner opens gets the same title bar as the app, and switching themes updates the ones already open.

ByteRunner now has a byterunner command for Command Prompt, PowerShell and Git Bash: byterunner run report.kt runs a saved query (a .brpad, or a .kt, .java, .groovy or .scala file) and prints its results, without opening the app. The exit code says whether it worked, so it fits in scripts and scheduled tasks. byterunner --help lists the options.

It's off until you want it. The first time 1.0.87 opens, it asks once whether to add the command; Preferences → Terminal turns it on or off at any time. It goes on the PATH for your Windows account only (no administrator rights), and new terminals pick it up. Uninstalling ByteRunner takes it back off.

In a typed query, a decimal column (the usual type for money) wanted its value written as a BigDecimal, so orders.where { o -> o.total gt 100.0 } didn't compile; nor did o.ratio gt 1 on a floating-point column. Now any number works: 100.0, 100, 100L, for gt, lt, eq and the rest. Checked against real PostgreSQL, MySQL and SQL Server databases.

A class from one of your query's packages (added with @file:DependsOn or in Query Properties) now gets suggestions after a dot, in Kotlin and Java, like any other class. Before, its type was known but nothing was listed.

Trust a self-signed MySQL or MariaDB server

Trust server certificate now appears for MySQL and MariaDB connections, not just SQL Server. Tick it for a local or self-signed server (a Docker one, say): the connection stays encrypted, and the certificate isn't checked. If you had added sslMode yourself, yours still wins.

The red underline that marks a mistake as you type (an unknown method, a type that doesn't fit, a typo) used to work only for Kotlin, and only with no database selected. Now:

• Java queries are checked too, by the same Java compiler that runs them.
• Queries on a database are checked against that database. Users and u.id are known, so a misspelt column (u.nmae) or table is underlined before you run. The tables and columns are read once from the database and kept for a few minutes, so typing never waits on it.

Hover over an underline to see the compiler's message.

Choosing a function from the suggestions (say fromString after UUID.) slipped an invisible character in after its name. The cursor then sat one place away from where it looked, so Backspace and Delete removed the wrong character, and a stray ) seemed impossible to delete.

• Functions go in with their brackets, the cursor on the first argument, ready to type over; Tab moves to the next. A function with no arguments goes in as name(), and a property as just its name.
• The invisible character is gone for good: the editor removes it however it arrives, so a query that already has one is cleaned when you open it.

Choosing Update now closed ByteRunner, but the new version often didn't install, and the next start offered the same update again. The installer was being closed along with ByteRunner, partway through. Now Windows runs the installer on its own, it waits for ByteRunner to close, installs, and opens the new version. And if an update ever doesn't install, ByteRunner tells you when it next starts, with what the installer said, instead of quietly offering it again.

If you're on 1.0.81 or earlier, install this version by hand once: your copy still has the old Update now. Download ByteRunner-1.0.82-Setup.exe from byterunner.dev and run it; your queries, connections and settings stay as they are. From then on, Update now works.

After you type a dot, the suggestions now come from the same Kotlin and Java compilers that run your query. Whatever compiles, completes, however the value got its type:

• Kotlin: destructured values (val (name, age) = … then name.), if and ?: expressions, functions with a declared return type, runCatching { … }, with(x) { this. }, the result of Util.cache, and lambda parameters however deeply they're nested.
• Java: var from any expression, streams you've collected, map entries inside a lambda, ternaries, Optional values, and chained builder calls.

On a set of harder cases, the old suggestions found 6 of 36 expected members; the new ones find all 36.

Nothing is run to work this out, and code with mistakes elsewhere still gets suggestions. Kotlin also now offers its built-in number operations (toInt(), plus) and Result's members (getOrNull, isSuccess). A long query takes a moment longer the first time; the list updates itself when the compiler's answer arrives.

ByteRunner now talks to NVDA and JAWS. The Java Access Bridge they use to read Java apps ships with ByteRunner and is switched on for it alone (no system setting to change), and every part of the window says what it is:

• Buttons, tabs, drop-downs and checkboxes are announced as such, with their names, including the icon-only ones (Add, Refresh, Close Tab, the debugger's step buttons).
• Trees and tables open and close out loud: a folder or table in the Explorer, a result table, or a related-rows link says whether it's expanded or collapsed.
• Results read with their column: moving through a result grid, each value comes with its column's name.
• Every form field has its label, so an empty field in Add Connection is "Host" or "Password", not just "edit".

The whole app from the keyboard

• You can always see where you are: whatever has keyboard focus gets a clear two-tone ring.
• Tab and Shift+Tab reach every control in every panel; Enter or Space presses it.
• Arrow keys move through the Explorer, My Queries, the welcome screen and drop-downs; Right opens a folder and Left closes it.
• Escape closes every dialog.
• A connection's Edit and Delete appear when you Tab to it, not only on mouse hover.

Easier to read

All text now meets the WCAG AA contrast standard (4.5:1) in both themes. The grey used for secondary details, the teal and orange used as text in the light theme, and the code editor's comments and line numbers are all a shade stronger, and white text on the light cyan buttons in the dark theme is now dark.

ByteRunner now works out how your database's tables relate, and puts it to use in your results:

• A key opens the row it points to. In a result from Orders, click a user_id to see that user, or a product_id to see that product.
• A row opens the rows that point to it. Results from Users get an Orders column: click it on a user to see their orders.
• Everything opens right under its row, loading from the database only when you click, and what opens is linked the same way, so you can walk from a user to their orders to a product.
• It works for a table (Users), the typed API (Orders.where { … }), and query("SELECT …") over a single table.

It uses your database's foreign keys, and where none are declared it infers relationships from column names (customer_id pointing to customers) when there's exactly one match of the right type. Inferred links are labelled as such. The relationships are found in the background as soon as you pick a connection.

Relationships in the schema tree

Expand a table in the Explorer to see its Relationships: the tables it points to (→ Users), the tables that point to it (← Orders), and the columns that link them. Key columns show where they point, inferred ones included. Click a table to insert its name.

Some dialogs had a fixed size, and when their text ran longer than expected their buttons were pushed out of sight. Update Available hid its Update now button; Go to Line hid its buttons altogether; Find and Replace cut off its options. Dialogs now size themselves to what they show, so every button is always there. The License dialog also follows dark mode now.

A clearer update screen

Updating now shows what's happening at each step:

• Download → Check → Install, with each step ticked off as it finishes.
• How much has arrived of how much, the speed, and about how long is left.
• Why it's safe: the installer runs only if it matches the fingerprint published for that version and is signed by ByteRunner's publisher.
• When it's ready, it says ByteRunner will close, install and reopen, rather than just disappearing.

A query's imports and packages no longer have to sit at the top of its code. They live in Query Properties (F4), saved with the query, so the editor shows just your code.

• Packages are part of the query now. In Query Properties, type a name like com.google.code.gson:gson: ByteRunner checks Maven Central, adds the newest version, and downloads it. (This replaces Manage Dependencies, which wrote lines into your code.)
• Alt+Enter on a class that needs an import adds it to the query's imports, with no import line.
• Got a query with imports at the top? Query → Move Imports & Packages to Query Properties takes them out of the code in one step. Old @file:DependsOn lines keep working either way.
• The editor's header shows "2 imports · 1 package"; click it to open Query Properties.
• Java queries now honour the imports set in Query Properties too.

Mistakes are underlined as you type

A moment after you stop typing, ByteRunner checks your Kotlin query with the compiler, without running it. An unknown method or class, a wrong type or a typo is underlined in red right where it is, and hovering shows why. A class that just needs an import keeps its Alt+Enter hint instead.

Queries on a database connection aren't checked yet, and Java and Groovy queries are next.

Click a nested value in your results, like [7 items], and it opens right under its row instead of in a window of its own. Click again to close it. Several can be open at once, lists inside them open the same way, and an open list stays in view when the table is scrolled sideways.

This also fixes a crash: opening a list inside one of those windows failed with "layouts are not part of the same hierarchy". Values with nothing more to show, like (empty), no longer look clickable, and labels like [2 items] are no longer cut off.

Imports fold away, and Alt+Enter adds a missing one

• The @file:DependsOn and import lines at the top of a query fold into their first line when it opens, so you start on your code. Click the fold marker to see them.
• A class used without its import is underlined, and hovering it says which import it needs. Alt+Enter adds it after your other imports; when the name exists in more than one package, pick from a short list.
• Suggestions come from the Java and Kotlin libraries and your query's own packages (once a run has downloaded them). Names ByteRunner can't place, like your own variables, are left alone.

Also fixed

• ByteRunner's log no longer collects entries from its own test runs, so what's in it is really from your use of the app.

In dark mode, the Query editor had white strips down its sides: the breakpoint column on the left and the scroll bars on the right and bottom. They're dark now, and the scroll bars are slimmer and match the editor in both themes.

Ask the Agent tab for something that needs a library — "use Gson to turn this into JSON", "list my DynamoDB tables with the AWS SDK" — and it adds the package itself. Both agents, ByteRunner's own and Claude Code, can now see which packages a query uses, add one, and remove one.

• With no version given, it picks the newest stable release on Maven Central.
• A package is downloaded before it's added, so a wrong name is caught at once with a clear message, not as a confusing error on your next run.
• Packages are the @file:DependsOn("group:artifact:version") lines at the top of the query, as before. Nothing new to learn if you add them by hand.

The whole Java library, in every install

Scripts that used java.net.http.HttpClient — or a few other standard Java modules — failed with "not found" in the installed app, though they worked in development. ByteRunner now ships the complete standard Java library, so anything in the JDK is there for your scripts.

Also fixed

• Shift+Enter starts a new line in the AI tab's message box; before, it sent the message. Enter still sends — the same as the Agent tab.

The Agent tab's Claude Code option no longer just edits and hopes. It can now run the query in ByteRunner, read the results or the error, and fix what failed — the same loop you'd go through yourself. It can also look up the connected database's tables and columns, so it uses real column names instead of guessing.

• Before a run, it asks you in the conversation. Always run in this conversation stops the asking — except on a connection marked Production, where it asks every time.
• Its edit goes into your editor before the run, so you see exactly what ran. If you've changed the query yourself in the meantime, your version stays and nothing runs.
• It all happens on your computer: ByteRunner's tools are only reachable by the Claude Code it started for that conversation.

Set up in one click

If Claude Code is installed, ByteRunner now offers it the first time you open a query — it uses the Claude account you signed in to Claude Code with, so there's no API key to set up. Before anything is sent, a short notice explains what goes to Anthropic and links to their privacy policy. Nothing is sent until you accept it.

When a new version comes out, the update notice now has an Update now button. ByteRunner downloads the new version, checks it's the genuine installer — it must match the fingerprint published for that release and be signed by ByteRunner's publisher, or nothing is installed — asks you to save any changes, then installs it and reopens. No browser, no download folder, and no "ByteRunner is already installed" prompt.

It's there when ByteRunner was installed with Setup.exe. The MSI keeps the Download button. If you installed with Setup.exe, this is the last update you install by hand.

Claude Code works without AI Settings

The Agent tab's Claude Code option uses your own Claude Code sign-in, but it was greyed out until AI Settings had a provider configured. It no longer needs one — and when Claude Code is installed, the Agent tab opens on it.

Also fixed

• Enter sends in the Agent tab, as it does in the AI tab. Shift+Enter starts a new line.
• Run Tests works with tests that use your query's own functions or values. Every such test failed with a cryptic <init>() error; they now run and report pass or fail properly.

Run Isolated (Ctrl+F5) and JDWP debugging couldn't start in the installed app unless you'd picked a separate Java in Java Versions. The Java runtime bundled with ByteRunner was missing the java launcher both of them start. It's back, taken from the same Java the runtime is built from.

This slipped through because it only happens in the installed app, never when ByteRunner is run from source. Every release now runs a self-test inside both installers before it ships (Kotlin, Groovy and Java runs, an isolated run, the sample database, every database driver and more), so a problem like this stops the release instead of reaching you.

The Agent tab has a second agent: ByteRunner. Ask for something — "this throws, fix it", "show the top customers by revenue" — and it works the way you would: it reads the query, looks up the real tables and columns, edits the query, runs it, reads the result or the error, and fixes it until it works.

• It asks before it runs anything. Run once, run for the rest of the conversation, or don't run. On a connection marked Production it asks every time.
• Your typing wins. If you change the query while it works, its edit isn't applied.
• Its runs are ordinary runs: results appear in Results, and Stop stops them.
• Click any step in the conversation to see exactly what the agent saw.

It uses the provider in AI Settings: Anthropic, OpenAI, or a local Ollama model, where nothing leaves your machine. Local models need tool support, such as qwen3 or llama3.1. The Claude Code agent is still there, one click away.

My Queries: a home for your saved queries

The sidebar's My Queries is now a real folder — Documents\ByteRunner Queries by default, changeable in Preferences — shown as a tree:

• Folders and queries as they are on disk, with pinned queries on top.
• Right-click for New Folder, Rename, Move to…, Pin, Show in Explorer, Delete (F2 and Delete work from the keyboard). Delete goes to the Recycle Bin, and nothing is ever overwritten.
• Save As for a new query starts there, and Search Scripts (Ctrl+P) covers the whole library.
• Queries in your library open without the untrusted-file warning; files from anywhere else still get it.

Also changed

• AI uses the newest model by default. With no model chosen, the AI tab and the agent use the newest Claude Opus your key can use, looked up automatically, instead of an older fixed model. A model you choose in AI Settings is always used as is.
• Renaming or moving an open query updates its tab, so saving doesn't recreate the old file.

Long queries no longer go quiet until they finish. Results now appear as they are produced, so a ten-minute import shows its first rows straight away instead of everything at the end.

Three new helpers make the results pane something a script can drive:

• Util.progress shows a progress bar above the results while the query runs: Util.progress(done, total), a fraction, or just a message. It goes away when the query ends. A loop that reports progress can now be stopped, which Stop couldn't do for a busy CPU loop before.
• Util.live("Status") keeps one spot in the results that update(value) replaces in place, for a counter, a status line or a growing table, instead of dumping a new copy each time.
• Util.button("Refresh") { ... } puts a button in the results. Clicking it runs the code like a small query of its own: Stop works, and what it dumps is added below the results.

val count = Util.live("Clicks", 0)
var n = 0
Util.button("+1") { count.update(++n) }

Big and tangled objects no longer hang the app

dump() used to open every object ten levels deep at once. An object that points back at its parent, or a large web of objects, didn't render slowly, it froze ByteRunner. Now the first two levels show straight away and deeper ones open one level per click. A reference back to an object already on screen shows as (cycle: Type) instead of being opened again.

Kotlin autocomplete knows your variables

Type val names = listOf("a", "b") and then names., and you now get the list's members and Kotlin's own extensions: map, filter, sumOf, first and the rest. Lambdas carry the type through, so names.map { it. offers String members. Properties read the Kotlin way (p.first, not p.getFirst()), and data classes you declare in the query offer copy().

Also fixed

• The database picker only lists databases you can open. On SQL Server it offered every database on the server, including ones your login has no access to and ones that were offline.
• dump() from parallel code no longer loses output. Dumping from a parallel stream could silently drop rows.
• The open-source notices are complete again. A library added in 1.0.65 was missing from them.

A connection often points at one database — master, say — while the ones you actually want sit beside it on the same server. Until now that meant saving a separate connection for each. Now the toolbar has a database picker next to the connection: choose which database this query runs against, and the choice is remembered with the query.

The list is whatever the server reports to your login. The Explorer follows along too — its tables, and the typed accessors and column completions built from them, describe the database you picked rather than the one the connection was saved with.

The picker appears for SQL Server, PostgreSQL and MySQL/MariaDB when the server has more than one database. SQLite files and DynamoDB don't get one, since there's nothing to choose.

Also fixed

• The Environment picker works from the keyboard. In Add/Edit Connection you could tab to it but not open it. Now every picker in that dialog behaves the same way: Up/Down change the value, Enter or Space opens the list, and Escape closes it.
• Connections are sorted by the name you see. The Explorer sorted by each connection's underlying name even when it showed an alias, so the order looked random. It now sorts by what's on screen, within each group.
• The AI tab points somewhere real. Before you've set it up, it told you to go to a "Settings" menu that doesn't exist. It now has an AI Settings… button that opens the right dialog (also under Tools → AI Settings).
• Code samples in What's New render properly, as code blocks rather than raw backticks.

The output panel has a new Agent tab. Describe a change — "make this use the typed API", "handle the case where the row is missing", "this throws on empty input, fix it" — and the agent rewrites the query in place. No copying code out of a chat window.

It runs on your own Claude Code install, signed in with your own account. ByteRunner never sees your credentials and adds nothing to your bill. If the CLI isn't there, the tab says so and how to install it; if it's installed somewhere unusual, point ByteRunner at it in Tools → Preferences → Claude Code.

Some deliberate choices worth knowing:

• It works on a copy, never your file on disk. Your unsaved buffer is what the agent sees, and its edit comes back into the editor for you to run or undo. Nothing is saved behind your back.
• If you edit the query while the agent is working, you win. Its change is dropped rather than overwriting what you just typed, and the panel tells you.
• It can't run commands unless you let it. Editing is enough for most asks, so that's all it starts with. Tick Let it run commands to allow more; blocked attempts are reported instead of failing silently.
• Each query tab keeps its own conversation, so switching tabs doesn't hand the agent someone else's history.

The existing AI tab is unchanged — three providers including local Ollama, for asking questions rather than handing over the keys.

Also fixed

Release notes containing a code sample rendered their markup literally in "What's New". Fenced code now renders as a code block, and bold-wrapped code no longer shows its backticks.

Every Kotlin, Groovy and Java query now has Util — helpers available without an import. The one worth knowing is Util.cache:

val orders = Util.cache("orders") { query("SELECT * FROM slow_view").rows }

dump(orders.filter { it["total"] as Int > 500 })

The first run pays for the query. Every run after that reuses the result, so you can keep editing the line below it without waiting. Add a TTL — Util.cache("queue-depth", 30) { ... } — for things that move on their own, and Util.clearCache() when you want a fresh pull.

The rest of the set covers what a scratchpad session keeps needing: Util.elapsed { } to time a block, Util.retry(5) { } for a flaky call, Util.read/write/append for files, Util.httpGet /httpPost/download for the network, Util.cmd to run a command, Util.copy/paste for the clipboard, and Util.desktop/downloads/temp/appData for the places files go.

Type Util. in the editor to see them all with descriptions, or open Help → Script Helpers for the full reference. Your own helpers still live in File → Edit My Extensions — and if you declare something called Util yourself, yours wins.

Tools → Java Versions… lets you pick which Java an isolated run (Ctrl+F5) executes on — useful for checking that a script behaves the same on the runtime your servers use. ByteRunner finds the JDKs already installed on your machine, and can download Java 21, 22, 23 or 24 for you if the one you want isn't there. Downloads are verified before they're installed, and you can remove the ones ByteRunner downloaded.

Java 21 is the minimum, and the normal Run always uses the bundled Java 21. Older versions you already have are listed as unusable rather than quietly missing.

Connections can now be marked Prod, Staging, QA or Dev. The environment colours the connection in the sidebar *and* tints the connection selector in the toolbar, so production is obvious before you press Run rather than after. Pick it when adding or editing a connection; Prod is red by default and the colour can be changed.

Imported connections say what they need

Passwords can't be imported — the tools they come from store them encrypted — so an imported connection arrives complete except for its password. Those connections are now flagged Needs password in the sidebar, and if you run one anyway the error says so plainly instead of blaming the login.

Choose what to import from

The import window now lets you pick which tools to import from, instead of always scanning everything.

Tidier connection list

Connection rows no longer repeat the database engine in their second line — the icon already shows it — so more of the list fits on screen.

Confirmation dialogs stayed light even in dark mode, and a longer message could push their buttons out of view — the new Delete All Connections dialog was hard to read as a result. They now follow your theme, size themselves to their message, and offer a single clear choice instead of two buttons both labelled "Cancel".

Delete all connections from the sidebar. The Connections section header now has a delete action next to +, so clearing them doesn't mean hunting through a menu.

Installing or updating ByteRunner paused for about 30 seconds near the end and then reported "Install Partially Succeeded" — even when the install was fine. ByteRunner wasn't responding to a signal the installer sends at the end of setup, so the installer waited, gave up, and warned you. Installs now finish promptly and without the warning.

Start over with connections

Tools → Delete All Connections… clears every saved connection at once, for when you'd rather re-import from scratch than fix them one by one. It tells you how many will go and asks first.

Every result grid now has Copy and CSV in its header. Copy puts the rows on the clipboard tab-separated, so they paste straight into spreadsheet columns; CSV saves a file Excel opens cleanly. Both export the whole result, not just the rows on screen.

Run scripts without opening ByteRunner

A saved query can now be a scheduled job or a build step. Point the new command-line runner at a .brpad or a source file and it runs the same engine, prints results to standard output, and exits non-zero if the script fails — so a pipeline can act on the result.

Faster first run

Your first Kotlin query used to wait about three and a half seconds while the compiler warmed up. ByteRunner now does that in the background at startup, so it's closer to half a second.

Connections

• Editing a connection now takes effect. Changing a host, password or TLS option could silently keep using the old settings until you restarted.
• Connection errors explain themselves. A failure caused by an untrusted TLS certificate — common with internal SQL Servers — now tells you that "Trust server certificate" is the setting to turn on, instead of showing a certificate-path error.
• The connection window fits its contents, is more compact, and shows a scrollbar when there's more to see — options near the bottom are no longer easy to miss.

Ctrl+Shift+T now toggles the theme everywhere. The shortcut only worked while a query editor had focus, so it did nothing on the Welcome screen or with the output panel or sidebar focused — even though the View menu advertised it.

• The window title bar now matches your theme. On Windows it followed the system setting, so a dark ByteRunner could sit under a bright white title bar. It now follows the app's own theme and updates the moment you switch.
• "What's New" shows just your version. It was listing every past release's notes together; now it shows the notes for the version you're running.
• The installer's splash no longer clips the descender in "ByteRunner".

The Buy Pro… button now opens the ByteRunner Pro page on byterunner.dev, where you can see what Pro includes and purchase it — previously it could land on a checkout that was no longer current. The license agreement's contact address has been corrected too.

Already have a key? Nothing changes — activation is unchanged and fully offline.

You can now purchase a Pro license right from the app. Open Help → Manage License → Buy Pro… to go to checkout; paste the key you receive and Pro unlocks instantly — autocomplete, debugging, database connectivity, AI assistance, package management, and charting. It's a perpetual license with offline activation (no account, no phone-home), and the same key works on your other machines.

Already on the 14-day Pro trial? Nothing changes until it ends — then a Pro key keeps everything unlocked.

About → Open-Source Licenses and About → License Agreement now open the full text right inside ByteRunner — the third-party open-source notices and the end-user license agreement, both scrollable and selectable.

If ByteRunner ever hits an unexpected error, it now shows a clear message pointing you to the log file instead of failing silently, so you know to save and restart.

Bring your existing database connections into ByteRunner instead of retyping them. Tools → Import Connections finds connections you've already set up in:

SSMS — your registered servers

Other query tools — your saved connections

Pick which ones to import from a preview. Windows-authenticated servers work immediately; for SQL-login connections, ByteRunner imports everything except the password (which you add afterward — passwords are never read from the other tools). Connections that don't map to a server (LocalDB, attached database files) are listed with the reason instead of failing silently.

New File menu commands for working with multiple queries:

New Query (Same Properties) — a fresh query that inherits the current language and namespace imports.

Clone Query — duplicate the current query into a new tab.

Close All Tabs, Close Unmodified Tabs, Close Untitled Tabs — tidy up in one click. Closing tabs with unsaved changes asks first; there's always at least one tab left open.

Find and open your saved queries fast. File → Search Scripts (Ctrl+P for quick-open, Ctrl+Shift+F for search) opens one dialog that searches across your recent files and the scripts in your folder.

Type a file name to quick-open it, or type any text to find the scripts that contain it — matches show the line they were found on.

Use ↑/↓ to move through results and Enter to open the selected one (or just click).

Each query now has a Properties window — Query → Query Properties (F4).

Namespace imports: add import paths (e.g. java.util.* or kotlin.math.max) and use those types in the query without writing the import. They apply on every run and are saved with the query (.brpad).

At a glance: the query's language, connection, and dependency count, with a shortcut to Manage Dependencies.

Write tests right in a query and run them. Query → Run Tests (Alt+Shift+T) finds every @Test method your Kotlin query declares, runs it, and reports pass/fail per test with the failure message and duration.

JUnit's @Test and kotlin.test assertions now ship with ByteRunner, so you can just write them.

Results appear as a table, titled with the tally (e.g. "Tests: 3/4 passed").

Queries can now use import statements. Previously any query starting with an import failed to compile ("Expecting an element") because ByteRunner's injected helpers landed above it. Imports are now hoisted correctly — this affected Kotlin and Groovy queries alike.

Define helper functions and types once, use them in every query. File → Edit My Extensions opens a per-language file (Kotlin or Groovy) that ByteRunner prepends to your scripts automatically.

Write fun greet(name: String) = "Hello, $name!" in My Extensions, then call greet("world") from any Kotlin query — no import needed. import lines in the file are supported (they're hoisted to the top for you).

Edit it like any file; Ctrl+S saves, and the changes apply on your next run.

Settings now live in one place — Tools → Preferences (Ctrl+,):

Editor — font size, word wrap, line numbers, code folding, and auto-indent.

Appearance — dark/light theme.

Startup — show the welcome screen or not.

Changes apply instantly and are remembered across restarts. Your editor font size and the other editor toggles now persist — previously they reset every launch.

ByteRunner now checks for new versions on startup and tells you when one is available, with a link to the download page. You can also check any time from Help → Check for Updates.

Notify-only — ByteRunner never installs anything on its own.

What’s New → View Online now opens this release-notes page.

A "What's New" dialog now appears once after each update, summarizing what changed — and it's available any time from Help → What's New. The notes ship inside the app, so it works instantly and offline.

Fixed: the About dialog now reports the correct version (earlier builds always showed 1.0.0).

Full-Screen Results (F8) maximizes the output pane; press F8 again to restore.

Hide Editor collapses the editor so results fill the area.

Results Side-by-Side (Ctrl+F8) places the editor and results next to each other instead of stacked. Your choice is remembered across restarts.

A new Query → Run Isolated (Killable) action (Ctrl+F5) runs your Kotlin/Groovy script in a separate process whose Stop actually terminates it — even a runaway while (true) {} loop.

The normal Run (F5) is unchanged: fast, in-process, with database, dependencies, and cross-run session variables.

The debugger is now first-class: a Debug menu exposes Start Debugging, Continue, Stop, Step Over/Into/Out, Run to Cursor, Toggle Breakpoint, and Clear All Breakpoints.

Editor shortcuts: F9 toggle breakpoint, F10 step over, F11 step into, Shift+F11 step out, Ctrl+F10 run to cursor.

Branding cleanup: ByteRunner is now consistently described as "An interactive scratchpad for the JVM." No functional changes.

New modern Windows installer (ByteRunner-1.0.36-Setup.exe): a sleek, borderless install with a branded splash and progress bar — no clunky wizard. Recommended for most users; just download and run.

ByteRunner-1.0.36.msi remains for silent / enterprise (Group Policy) deployment.

Update notifications: ByteRunner now checks for new versions on startup and lets you know when one is available (Help → Check for Updates..., with a Check for Updates on Startup toggle). It only notifies — nothing is downloaded or installed automatically.

Language menu: all four languages now show (Groovy was being clipped) and are sorted alphabetically.

Windows now gets a .exe installer alongside the .msi. The .exe carries the ByteRunner icon as its file icon in Explorer (an .msi can't — that icon is a fixed Windows system association for all installer packages). Both installers share the same fully branded setup wizard (dark-navy welcome panel, chevron logo, formatted EULA).

ByteRunner-1.0.35.exe — recommended for most users; double-click to install, branded file icon.

ByteRunner-1.0.35.msi — for silent / enterprise (Group Policy) deployment.

Every future build brands both automatically.

The installer's End-User License Agreement now renders as a properly formatted document — brand-navy title and section headings, bold terms, and bullet lists — instead of raw Markdown text. EULA.rtf is generated from EULA.md at build time so the source stays single-authored.

The Windows installer now matches ByteRunner's brand. The setup wizard's banner and welcome/finish panels carry the dark-navy + teal/orange chevron design and ByteRunner wordmark, replacing jpackage's default red radial background. The wizard also has a license-agreement page, an install-location chooser, and a desktop shortcut.

Branding is applied automatically to every MSI build (a post-process step that swaps the WiX image streams), so future releases stay on-brand.

Your dark/light theme choice now persists no matter how you toggle it (menu, Ctrl+Shift+T, command palette, or the toolbar button) — previously only the toolbar button saved it, so the app could reopen in the default theme after a restart or reinstall.

AI replies now render Markdown (bold, bullet lists, headers, inline code) instead of showing raw ** and backticks. The database schema lookup for the AI is also more robust: it falls back to the last run's auto-discovered tables, logs why a live lookup failed, and — if tables still can't be listed — tells the assistant the connection is active rather than denying it.

Completes the AI assistant's context: alongside your code, language, database connection, and last error, it now also receives the script name and the active Query mode (Statements/Expression/Program), and is told to write for that mode — so responses fit exactly what you're doing.

The AI assistant now always knows about your active database connection. It previously only saw a schema if you had expanded the connection in the Schema Explorer; now selecting a connection is enough — the assistant is told the connection name/type and its tables (discovered live if not yet loaded), so it stops claiming there is no database and can write real queries.

Sharpens the AI assistant's ByteRunner-awareness: dump() is framed as an always-available injected global (models no longer claim it's undefined), and the assistant is told to use a connection's exact table/column names and only assume a database when one is present. Adds a headless aiHarness dev tool for iterating on the assistant without the GUI.

The AI panel can now export a conversation to a Markdown file. An Export button next to Clear (shown once a conversation exists) writes the full transcript via a save dialog — user turns labelled 'You', assistant turns verbatim so code blocks stay intact.

The AI assistant is now ByteRunner-aware: its system prompt teaches the model the actual environment (snippets with no main(), dump() output, the fluent table query API and query(...) for raw SQL), so answers come back as idiomatic ByteRunner code instead of generic JVM boilerplate. Local Ollama requests also get a 5-minute ceiling (was 30s) so slow local generation no longer times out.

Fixes the menu bar: File/Edit/Query/View/Tools/Help dropdowns were rendering behind the code editor (and could get stuck open). They now draw fully above the editor, keep the custom dark styling, and close on click-away, Escape, re-click, or selection.

Local LLMs: the AI assistant can now run entirely on your machine via Ollama (llama, gemma, qwen, mistral, ...). Pick 'OLLAMA (local)' in AI Settings — no API key, configurable server URL, and nothing leaves your computer. Cloud providers (Anthropic, OpenAI) unchanged.

Maintenance and internal improvements.

Maintenance and internal improvements.

Maintenance and internal improvements.

Maintenance and internal improvements.

Maintenance and internal improvements.

Maintenance and internal improvements.

Dumping raw query rows — e.g. query("SELECT * FROM Table").dump() or dbo.Table.dump() — could show every cell as [error]. dump() was reflecting on the row list's own internal implementation fields (elementData/size/modCount) instead of rendering the row's actual values. Rows now render correctly as nested tables.

Fixes #20.

Download ByteRunner-1.0.15.msi and run it to upgrade in place.

Resizable Explorer sidebar — drag to resize, just like the editor/Results split.

Both panel sizes now persist across restarts (previously the editor/Results split reset to a fixed position every time).

Resize cursor on hover for both dividers, and a fixed divider color so it correctly matches your current theme (was previously a fixed grey regardless of light/dark mode).

Download ByteRunner-1.0.14.msi and run it to upgrade in place.

dump() now renders a list of maps (e.g. dynamoDb.scan(...).items()) as a proper table:

One column per item field (union of keys) instead of the Map's internals (m/keySet/…) that produced [error] cells.

DynamoDB AttributeValue values render compactly (S/N/BOOL/NULL/SS/NS/L/M → readable text).

So both DynamoDB query styles now render cleanly.

Fixes database scripting end-to-end. A Compose stale-closure bug made every Run/Debug compile with no active connection, so query(...), table accessors (dbo.Users / public.User), and the DynamoDB client came back "Unresolved reference". The run/debug/AI paths now always use the currently selected connection.

DynamoDB (NoSQL) support, with the AWS SDK correctly bundled:

Connect with region + Access Key / AWS profile / default credential chain (+ optional local endpoint).

Query via PartiQL — query("SELECT * FROM \"Table\"").dump()

Native AWS SDK client in scripts — dynamoDb.scan { it.tableName("Table") }...

Superseded by v1.0.12. This build shipped without the AWS SDK bundled and with a connection bug that broke database scripting. Please use v1.0.12 instead.

Feature release.

The auto-discovered table accessors now support the fluent query idiom directly, with dialect-aware SQL (SQL Server TOP/OFFSET-FETCH + [bracket] identifiers; LIMIT/"quotes" elsewhere): dbo.Users.take(1).dump() dbo.Users.where("active = 1").orderBy("name").take(10).dump()

Unresolved reference: <schema> (e.g. dbo) when querying tables. The fluent table accessors are now auto-discovered from the connected database, so dbo.Customers (and any schema) resolves immediately — no need to expand the schema explorer first. Verified end-to-end against a live SQL Server.

The accessors are Ktorm tables, so use: query("SELECT TOP 5 * FROM dbo.Customers").dump() // raw SQL db.from(dbo.Customers).select().limit(0, 5).map { it }.dump() // Ktorm DSL

SQL Server / H2 queries through Ktorm no longer fail with "More than one dialect implementations found in the classpath." ByteRunner now always selects an explicit Ktorm dialect (SQL Server uses SqlServerDialect).

Everything from v1.0.4 (SQL Server Windows authentication, TLS trust toggle, keyboard-navigable dropdowns, new brand mark + dark UI) is included.

Desktop scratchpad for the JVM — Java, Kotlin, Groovy, Scala — with rich dump() output, databases, debugging, and AI.

SQL Server Windows authentication — Integrated (current Windows account, no password) and NTLM (DOMAIN\user), alongside SQL Server auth.

SQL Server TLS — secure by default with a Trust server certificate toggle for local/self-signed servers.

Keyboard-navigable connection-dialog dropdowns (arrows / Enter / Esc).

New brand mark — clean double-chevron "run" icon; refined dark theme, custom dark menu bar, Welcome screen, and IBM Plex Sans UI font.

Maintenance and internal improvements.

Maintenance and internal improvements.

Maintenance and internal improvements.

The first ByteRunner build: an interactive scratchpad for the JVM.

Run Kotlin, Java, Groovy, and Scala snippets and visualize results with dump() — tables, trees, JSON, and more.

Database connectivity with a schema explorer, breakpoint debugging, and a built-in AI assistant.