Commit Graph

64 Commits

Author SHA1 Message Date
Fabian @ Blax Software 6f60462d44 A converter tool: text in six encodings, hex, binary, decimal, octal, Base64; 8/16/32-bit words either byte order; Tools menu in the top bar
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-28 12:54:23 +01:00
Fabian @ Blax Software ef8f97b1c9 A RGB pixels: three inputs, eight colours, on the canvas and on a component's screen
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-28 12:51:09 +01:00
Fabian @ Blax Software 33318d84ca A logic analyzer: watch wires, cables and pins over time (right-click: Watch in analyzer), saved with the circuit
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-28 12:36:30 +01:00
Fabian @ Blax Software 652b048dbc BF box designer: cable sockets drag and reorder like pins, taking their lines along; port parts no wider than their title
Sockets on a component's box could not be dragged in the designer and got
pushed around when other pins moved. They are now picked and dragged like
any pin (onto or past a neighbour they swap), and the lines split out of
a socket move with it as one block.

The In and Out port parts measured their title at nearly twice its size,
so they were much wider than what they show.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-28 11:52:56 +01:00
Fabian @ Blax Software 3563ee9a95 R box designer: size by the corner, reorder pins, pick and move several, pixels one by one, fitted boxes, displays from inside in free spots
- A picked lamp, display or screen has a size grip on its corner.
- A pin dragged onto or past its neighbour swaps places with it (the
  order is kept in the design; boxes designed before keep theirs).
- Shift + click, or a box around things, picks several: dragged or moved
  with the arrow keys together, drawings among them deleted together.
- A screen can be split into its pixels, each placed on its own (they
  start where they sat, sized and turned as the screen was), or joined.
- New designs fit the box to what is on it (Fit, on and off): it shrinks
  as well as grows. A size typed in turns it off.
- A display of a part inside lands in the first free spot inside the box
  instead of under it, and keeps the size and turn its own box gives it.
- Pointing at a display from a part inside (in the designer and on the
  placed box) says which part it is from.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-27 13:54:30 +01:00
Fabian @ Blax Software 58d5b80322 A drop a cable's unused wires; BF pointed-at buttons let go, nothing pointed at while the view moves
A cable whose wires are partly unused (nothing feeds them at its bundle,
nothing takes them from a split) offers to drop them: its button, its
menu, e.g. 16 → 5. The rest close up in order with their names, each on
the row it had, so the wires to them stay where they are.

The buttons of a part pointed at went away only once the pointer rested;
moving on kept putting it off. They now go shortly after the pointer
leaves, and panning or zooming the view lets them go at once.

The speed test takes the best of three runs, so tests running alongside
can't fail it.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-27 13:42:47 +01:00
Fabian @ Blax Software fa849d7a05 A pick pins for a cable, buttons on pointing, right-click on pins; docked panels move freely
- Pointing at a part shows its round buttons, as if it were selected; they
  stay while the pointer goes to them.
- A box around some pins of one part (not over its middle), or Shift +
  click on pins, picks exactly those pins: a cable plug on them, wire them
  one by one, invert or unwire them, from buttons beside them or a
  right-click.
- Right-click on a pin offers what can be done right there first: split a
  component's cable socket into wires (or join), pull a cable out of a cable
  end, invert an input.
- A docked panel moves both ways now: moved up or down off its component's
  pins it lets go and stays a panel of its own (rows and wires kept);
  moved sideways it stays docked.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-27 13:34:16 +01:00
Fabian @ Blax Software 4dfd97d192 A browser back and forward through the circuits (mouse side buttons)
Every step into or out of a circuit, and to another project, is a browser
history entry holding the circuit and its crumbs. The mouse's back and
forward buttons, Alt + arrows and the browser's buttons go through them as
visited; a reload, or going back to an entry from before one, opens that
entry's circuit. In Chrome the mouse's back button on the first entry goes
up a crumb instead of leaving the editor. Share and puzzle pages open their
link only on the first load, so history landing on them does not reload it,
and the account sync starts once per page load.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 23:04:32 +01:00
Fabian @ Blax Software a29215162c A buttons beside the selection, a plug without a cable, bounds on split ports
- Round buttons on the canvas next to what is selected: split a component's
  connector port into wires or join it (beside each socket), pull a cable out
  of a plug, plug a cable end in or out, split a cable into single wires,
  bundle selected wires.
- The cable button on a component's pins puts just a plug there. Drag the
  cable out of its pin (or press Pull the cable out and click): the other end
  goes where it is let go, and on a part's pins its wires land on them.
- A split port's wires on the box are marked off by a line above and below
  in the connector's colour.
- A split plug with no cable yet is named after the pins it drives.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 22:45:47 +01:00
Fabian @ Blax Software ab47235e38 Merge branch 'feat/responsive'
# Conflicts:
#	app/components/editor/Help.vue
2026-10-26 18:54:49 +01:00
Fabian @ Blax Software bacc6af17e Merge branch 'feat/library'
# Conflicts:
#	README.md
#	app/composables/useEditor.ts
#	app/lib/logic/project.ts
2026-10-26 18:54:44 +01:00
Fabian @ Blax Software ef9a4a2a6b Merge branch 'feat/drag' 2026-10-26 18:54:28 +01:00
Fabian @ Blax Software 313f1849f4 Merge branch 'feat/ports' 2026-10-26 18:54:28 +01:00
Fabian @ Blax Software 596dc6827e BF memory: a newer save brings its own bits, bits reach the account when you leave, room for them
A project that comes in with the same circuit open (a newer save from
another computer, a savegame restored in place, a shared link opened
again) now runs from the bits it brings. Before, the running circuit
went on with this computer's old bits and wrote them over the newer ones
at the next save, and a savegame could not undo Power off and on.

Bits changed only by buttons or a clock are sent to the account when the
page is hidden or closed, when you leave the project, and before signing
out, so they are no longer lost by "remove from this browser" and reach
the other computer. A running clock alone still sends nothing. Bits alone
keep the project's save time, so an edit saved on another computer wins
over them and they end up in its savegames.

What circuits hold has its own room of 500 KB per project on top of the
2 MB limit, in the browser, the account and share links. When it is full,
the circuits left longest ago start from 0; a circuit that holds more than
that on its own says so once. A project can no longer become too large to
load because of its memory.

A savegame opened as a copy saves the project it leaves first, like every
other way of switching projects.

Tests now run the editor itself (in a stand-in browser with an account
server) for going into components and back, reloads, two projects, other
computers, savegames, signing out and the room limit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 18:44:43 +01:00
Fabian @ Blax Software b823e8fef9 BF library: no solutions inside, nothing into a campaign, marks only from the entry, a small listing, updates clear what they replace
A component with a challenge or puzzle solution anywhere inside stays
private, not only a challenge circuit itself, so wrapping a solution in a
part of its own no longer publishes it.

A campaign takes nothing from the library: Add and "Get version" are off
there, with a line saying why. A library part could be duplicated,
published again or taken apart into a solution, so a check on placing was
not enough.

Library marks come only from the entry being added. The server drops the
marks a publisher sends, and whether an entry is yours depends only on the
key this browser keeps for that project and component, so a part claiming
to be someone's entry can't be published over it.

The listing keeps pin counts and the first 16 pin names a side, short, and
a group of 40 characters at most, so it stays small whatever is sent.

"Get version" clears away what came along with the old version once
nothing else uses it, and the new parts take its names. Adding never
reuses another entry's component, so updating one entry leaves the others
as they were.

Wire corner points that aren't number pairs are dropped when a project,
link or library entry is read, so a circuit can always be drawn.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 18:44:13 +01:00
Fabian @ Blax Software 049f84eb64 BF split ports: no wire against the cable, pins that stay put, lines kept on unpack
A wire dropped on a socket with a cable in it only takes a line coming
out; the lines going in are the cable's, so it no longer drives one
against the cable. Wired by hand anyway, the check calls that an error,
like a signal sent by two parts. A line going in with neither a wire nor
a cable gets the usual "not connected (reads 0)" warning and marker.

While a wire is drawn over a socket it ends on the socket, where it goes
when let go, not on the pin below. Splitting or joining a port no longer
moves the pins on the other side of the box. Pins on their usual edge
come first, so a wire dropped on the box body takes those, and the cable
button only offers pins whose cable end sits outside the box.

Unpacking a component joins wires on its split lines to the parts that
used the line inside; wires that had nowhere to go are counted in a
notice. Docked panels line up with the moved ports when a project is
opened, not at the next edit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 18:38:32 +01:00
Fabian @ Blax Software d5a9447bf9 BF moving parts: bends that would run over a part or along another signal let go, the rest stays
Hand-placed bends stayed where they were when parts moved, and the router
takes such wires as fixed lines. So a wire to a moved part was joined to
its old bends by a straight piece that could cross that part (into its pin
from the wrong side) or other parts, run along another signal or over
someone else's pin; a part put down on a wire's bends lay right over it;
and wires of the same signal branched off those lines. The arrow keys also
froze picked wires into bends and shifted them even when one end stayed.

Now a drag and the arrow keys move parts the same way (move.ts), always
from where they started. Wires between parts that move together keep
their bends, moved along. A wire to a part that stays keeps the bends on
that side as long as the way through them is clear by the router's own
rules (a cable by its full width) and lets go of the others, which the
router lays out around the parts; a wire a moved part now lies on does
the same. Only these wires are looked at. What shows while dragging is
what stays, and the drop, a plug or latch included, is one undo step.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 18:21:34 +01:00
Fabian @ Blax Software 7d6b0f8fad A public library of components: publish yours, add everybody's
"Publish to the library…" in the menu on a circuit's name (or Space)
sends the component with every component it uses and their connector
types, under your leaderboard name. The server checks it like any
project, refuses what is missing, inside itself, nested too deep or too
big to run, and counts its transistors and pins itself. Publishing again
from the same browser makes the next version of the same entry; only that
browser holds the entry's key, so only it can update or remove it.
Challenge circuits and puzzle solutions stay private.

The Library (Components in the bottom bar, Space, the main menu) lists
every entry, newest first, searchable by name, description and author,
with a picture of its box, its transistors, pins and what comes along.
Add brings an entry into the open project and starts placing it: what the
project has in exactly that form already is used as it is, the rest comes
with new ids, a taken name gets a number, connector types join one with
the same lines. The This panel says where a component came from and
offers a newer version, which replaces it in place. A campaign only adds
what is built from parts it has earned, and its challenges take nothing
from the library.

Components keep an optional "from" mark; projects without it load and
compute as before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 18:14:46 +01:00
Fabian @ Blax Software 588165236c R bars and panels fit small windows, Main always in reach; A Space search opens components
The top and bottom bars keep their steady centred width on wide windows,
but never get narrower than 760px as far as the panels leave room, and
move off the centre rather than under a panel. On a narrow bar the words
go first, the names between Main and the open component fold into "…"
(a menu back to each), and sound, settings and help, then undo, redo and
share, then challenges and search move into a "⋯" menu. Main keeps its
house at every width; before, the rule that hid its label hid the icons
too, and on a squeezed bar the crumbs, Main with them, were cut off.

From 821 to 1100px the selection's panel floats over the canvas edge
between the bars instead of narrowing the canvas. The zoom buttons sit
above the parts bar where it reaches them. The challenges drop-down, the
flyouts and the search box stay on screen.

In the Space search, Shift+Enter (or Ctrl+Enter, or the pencil on a
component's line) opens the component to edit it instead of placing it,
and typing a name lists "Open <name>" for every circuit of the project,
also those that cannot be placed here; the one you are in shows as where
you are. A circuit on the way here is reached by going back along it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 18:12:40 +01:00
Fabian @ Blax Software e55bd47310 A memory that stays: circuits keep their bits across visits and saves; Power off and on
What latches, flip-flops, registers and RAM built from NANDs hold is no
longer lost when you go into a component and come back, reload the page or
open the project on another computer. Leaving a circuit puts its bits in
the project, and opening it starts from them.

Only the gates on feedback loops can hold a bit, so only those that are 1
are kept, plus the clocks that are high: each node id once, each gate as
the path levels it shares with the gate before plus the rest. 1,024
flip-flops take about 30 KB. Restoring runs the gates in the order signals
flow, so the gates in front of a latch are right before it reads them;
gates that no longer exist after an edit are ignored.

The bits go with every save, file, share link and account upload. Between
saves (a clock running, a button pressed) they are put in this browser's
copy every 30 seconds and when the page is left, without counting as a
change: no sync, savegame or undo step of their own, and never over a save
made in another tab. Projects without them start from all zeros as before.

"Power off and on" in the menu on the circuit's name, or with Space,
starts the open circuit again from all zeros.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 18:09:18 +01:00
Fabian @ Blax Software 1be913bd24 A ports on top of the box, split into lines to wire by hand
On a component's box every connector port now sits at the very top of its
side, above the single pins, in auto and hand-drawn boxes alike. A port
can be split on one placed component (its settings or right click: Split
… into lines): right below the socket the box then gets a pin per line,
named after the line, so lines can be wired by hand without an adapter.
Lines going into the component are inputs, lines coming out outputs, each
facing out of its side; a bar in the type's colour ties them to the
socket. A cable still plugs into the socket at the same time. Dropping a
single wire on a socket (or clicking one while connecting) splits the
port and takes the first free line that runs that way. Join … lines
takes the line pins and their wires away again, as one undo step.

A line wired by hand joins the same net the cable's line reaches inside;
a wire and a cable on one line both drive it, and the check says so.
Line pins are left out of the open-input warning, docked panels and
bubbles; docked panels no longer get a row for a port's socket either.
Saved as an optional list on the placed component (splitPorts); without
it a box only has its ports moved to the top.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 18:08:27 +01:00
Fabian @ Blax Software ad8f6897e0 A latch parts onto each other: pins touching, no wires, moving together
A part whose pins line up one for one with the pins it is wired to can
sit straight on them, like a display on a CPU's outputs or a switch on a
component's input. Drag it close (green rings show where) or choose
Latch onto in its menu or settings. It then moves with that part; drag it
away or Unlatch to let go. Parts whose shared pins already touch latch by
themselves, the smaller onto the larger. A pin that would touch another
without a wire keeps it from latching. A clamp marks the joint.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-23 15:34:36 +02:00
Fabian @ Blax Software b355939581 BF jumps always on top of what they cross; R circuit commands in a menu on its name, the side panel only says what it is
A jump is drawn once more over every line, so a cable that arches over
another is never hidden under it, whatever order they are drawn in. Cable
labels sit on the longest stretch no other line crosses.

The circuit's name in the top bar opens what can be done with it: tidy
its wires or every circuit's, design its box, duplicate, delete, print,
export SVG, publish as a puzzle. The This panel keeps what the circuit is:
its health, its numbers (the transistors tile opens their breakdown), its
truth table and how it looks as a part. Unused components are a tab of
the Components list in the parts bar, with a delete button on each.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-23 15:12:43 +02:00
Fabian @ Blax Software 24a62c3601 R wiring: nothing over or under parts, cables as wide as drawn, clear bridges, cables that split, tidy every circuit
Parts are walls with a margin: a line only touches a part where it ends on
its pin. When the usual route and its alternatives are blocked, a search
of the grid around the parts finds the way. Cables count as wide as their
sleeve, so they keep clear of each other. A further wire or cable of a
signal branches off the lines already laid, and cables of one signal are
drawn as one that splits. At crossings the thinner line jumps over the
wider one, as wide as it needs (vertical ones sideways); cables hop with
every line inside. Tidy every circuit lays out all circuits in one go.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-23 14:57:16 +02:00
Fabian @ Blax Software 51d71e2564 A Shift while wiring: connect and go on from the same signal
Shift + click on a pin while a wire follows the mouse connects it and
keeps wiring from the same output, so one signal fans out to several
pins in a row; Esc or a plain click ends it. Started at an input, it goes
on from the output just wired to it. Letting go of a dragged wire with
Shift held does the same.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-23 13:11:19 +02:00
Fabian @ Blax Software 55bba95098 R panel rows editor: drag to reorder, add above or below, gaps you can see, no folded settings
Each row is one line: a grip to drag it, its colour (click for the next),
its name, switch / button / clock as three icons, its key (or Hz for a
clock), remove. Pointing between two rows offers to add a row there or
more or less space; empty rows show as that much dashed space. Alt + up
or down in a name moves the row. Rows keep their wires when moved.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-23 12:59:16 +02:00
Fabian @ Blax Software 8300712a21 R bottom bar as wide as the top bar; Logic shows every gate; Space opens a search for parts and actions
The parts bar sits under the top bar at the same width, pinned parts on
the left (the wheel scrolls them when they do not fit), search on the
right. Logic lists NAND and every component drawn as a gate, pinned or
not. A tap on Space opens the search box at the mouse with the recent
parts and common actions (new component, find, truth table, fit, print,
…); Space held while dragging still moves the view.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-23 12:43:08 +02:00
Fabian @ Blax Software 821f468748 R parts in the bottom bar as drawn tiles in a strip that scrolls sideways
Pointing at a kind of part shows each one as it looks on the canvas, in a
strip the mouse wheel scrolls sideways, like a city builder's. Pin and
edit sit on each tile's corner. Components get a tab per group, opening
on the first group with something that can go in the circuit. The list
stays open while a part is dragged out of it.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-23 12:33:47 +02:00
Fabian @ Blax Software 97c650a2b8 BF inverted inputs: lamps and outputs show the inverted value, and checks read it
A bubble on a lamp or output pin now shows on it. The truth table, Check,
puzzle scores and gate detection read what an output puts out after its
bubble (they read the raw wire, so a bubble on an output was ignored), and
rows of an output panel count as outputs there (they always read 0).
Right-click on an input pin offers to invert it, for desktops that take
Alt+click for themselves.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-23 12:27:12 +02:00
Fabian @ Blax Software 24bc66f798 R Packed panels, Tab adds rows, flyouts at the pointer, steady top bar
Combining switches, buttons, lamps or outputs into a panel, and merging
panels, puts the rows right under each other (space 0). Tab in the last
row's name of a panel, or the last line of a connector type, adds the
next one once it is filled in. The bottom bar's lists open centred above
the pointer. The top bar keeps the width it has with both panels open,
centred, so it no longer grows and shrinks with the panels.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 22:47:38 +02:00
Fabian @ Blax Software 6398381550 R This tab: title, health, four tiles, tidy folds
The circuit name is the panel's title, edited in place, with where it is
used below. One line says whether all is good or how many problems
there are; inputs, outputs, transistors and delay sit in tiles. The rest
folds away with plain titles: truth table, as a component (fields one
under another), transistors (name, count × each, total), unused
components (only when there are any) and tools. The tabs are a
segmented control with the hide button beside it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 20:53:43 +02:00
Fabian @ Blax Software c1b70a937f R Panels: This and Pins on the left, the selection on the right
The left panel is about the circuit you are in: This (challenge and
Check on top, problems, name, statistics, truth table, as a component,
transistors, tools) and Pins. The selection gets its own panel on the
right, there only while something is selected, with its settings and
actions such as making a component out of it. The bars follow the
canvas width and drop labels when it gets narrow.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 20:38:17 +02:00
Fabian @ Blax Software 71332a1dfa R Top bar floats over the canvas, side panel full height
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 20:24:52 +02:00
Fabian @ Blax Software 6e3405ae0c R Top bar like the parts bar, no left panel
The parts panel on the left is gone: pinned parts sit at the start of the
bottom bar, components open from the pencil in its Components list (or a
double-click), examples load from there too. The side panel moved to the
left. The top bar floats across the whole width: menu with the project,
Main and the way into the open component instead of the circuit
selector, Challenges in a drop-down, clock, search, undo, settings,
share and account. / and the bar's search open quick add.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 20:17:41 +02:00
Fabian @ Blax Software 67e3d94d80 R a Figma-like workspace: a floating bottom bar of part kinds with flyouts, pinned parts on the left
- Bottom bar over the canvas: Logic, Inputs, Outputs, Wiring, Notes,
  Connectors, Components (and search). Pointing at one opens its parts
  above it: click to place, drag onto the canvas, pin to the left.
  Connectors offer Out/In, edit and new type; components come grouped
  with their transistor counts.
- Left panel: pinned parts first (NAND, AND, OR, NOT, XOR, input,
  output, lamp, clock to start with; kept per browser, components by
  name so they follow you into every project), then the circuits list.
  The long list of built-in parts and the connector list moved to the
  bar.
- Slimmer top bar and side panels; notices sit above the bar.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 20:04:43 +02:00
Fabian @ Blax Software 8de4a81678 A connector types of your own: HDMI, RJ45 or any bus, with out and in ports and one cable that carries every line both ways
- A project keeps connector types: a name, a colour and lines that run
  out -> in or back. Made, edited and deleted (once unused) from the
  parts list's new Connectors group and a connector dialog.
- "<type> out" and "<type> in" ports: inside a component a pin per line
  on the inner side plus a cable pin to pass the whole cable on to a
  part inside; on the component's box one port, coloured like its type.
- One cable joins an out port to an in port of the same type; the
  compiler joins line by line, forward and back, at every depth. Ports
  of different types never join; mismatched cables are pruned.
- Pins can face the other way (the inner pins of ports); the router
  takes them out and in from the side they face.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 18:59:56 +02:00
Fabian @ Blax Software c5b67ee7c1 R saves like a game: one save per project on every device, Load game in the menu, a pause menu, and a lean side panel
- Sync: when two devices changed the same project, the newer save wins
  everywhere and the other becomes a savegame of it (new endpoint to keep
  a savegame without replacing the save), never an "(other device)" copy.
  A first visit keeps its starter unsaved until something changes, and
  the main menu waits for the account's saves before anything starts.
- Main menu: Load game lists every save. In the editor, Esc with nothing
  selected (or the project button) opens a pause menu: Resume, Save,
  Save as copy, Load, Settings, How to play, Main menu. The projects
  dialog is gone.
- Selection tab: name and transistors on top, one icon row (open,
  duplicate, unlink, delete, more = the right-click menu), only the
  settings that matter for the part; pins, component tools, keys, cable
  and panel options fold away and remember it. X/Y fields removed.
  The Circuit tab folds its component settings, transistor breakdown
  and tools the same way.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 18:36:17 +02:00
Fabian @ Blax Software 9411527c5d A main menu: free play, campaign, challenges and leaderboard over a circuit that builds itself
Logigate opens on a title screen. Continue, Free play (your own projects),
Campaign (progress and what is next), Challenges (every challenge and the
puzzle of the week in one Challenges project), Leaderboard (the best ten of
this and earlier weeks, your place, your records), Settings. Arrow keys,
Enter and Esc work through it; links still open straight into the editor.
Players can name themselves on the leaderboards. The logo in the editor
leads back to the menu.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-22 12:22:35 +02:00
Fabian @ Blax Software 794acad140 A finer component boxes, a regrouped parts list with keyboard search, a real green for wires and cables
- Box designer: drag pins up or down to open gaps between groups; size (+/−) and turn (R) lamps, displays, screens and drawings; pixels belong to named screens, each placed on its own; displays of the components inside can be shown on the box (off unless ticked); a list of everything the box can show, each optional; the box grows to hold what it shows
- Lamps and displays deep inside placed components light up on the box
- Parts list: one search box for parts and components (letters in order match too), recently placed parts first, grouped Logic / Inputs / Outputs / Wiring / Notes, then components by group; groups fold away
- Keys: / searches the parts list (Enter starts placing), Shift+A or Ctrl+K adds a part at the mouse
- Wires and cables get a green; the default swatch shows grey, as the default really is

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-22 06:48:42 +02:00
Fabian @ Blax Software 09f945d2c5 A output panels, and switches, buttons, clocks or lamps combined into one panel
- Output panel: a column of named lamps, each passing its signal on; inside a component its rows are output pins (or kept inside); "Attach output panel" docks one to a component's outputs
- Select switches, buttons and clocks: Combine into an input panel (names, states, keys and wires stay; spacing kept); "All rows" makes them all switches, buttons or clocks
- Select lamps or output pins: Combine into an output panel
- Unnamed panel rows take the name of the pin they are wired to; output panels merge like input panels; circuits that place this one keep their wires when pins move into a panel

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-21 14:38:59 +02:00
Fabian @ Blax Software 7a00546e63 A parts dropped from the list connect where they land, cable buttons beside a selected part's pins, a reload offer for new releases
- Dragging (or placing) a part onto pins: its free pins land on pins they can join, a square away is enough, green rings show where; dropped, it is placed and wired in one step (Alt: just place)
- A selected component, panel or hex display shows a cable button beside its outputs and its inputs: one click for a cable onto those pins (or pick S0–S3, all 5, ...)
- Cable from outputs (or into inputs) whose pins already have one wire each takes those wires into the cable instead of adding a second path
- An open tab notices a new release within a minute and offers a reload (work is saved)

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-21 14:21:40 +02:00
Fabian @ Blax Software b19057b9d8 A cable straight off a component's pins: from its outputs or into its inputs, in groups like S0–S3
- Right click a component (or its settings): "Cable from outputs" / "Cable into inputs" with the pin groups it has (A0–A3, B0–B3, S0–S3) or all of them
- The cable end plugs onto those pins, the other end waits a few squares away with their names; drop it on the next part's pins and it plugs in there
- Also for input panels (rows out) and hex displays

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-21 14:13:24 +02:00
Fabian @ Blax Software deb94b9d61 BF input panels are component inputs, cable ends plug in more reliably; A merge panels, hex pass-through, design a component's box
- Inside a component, the switch and button rows of its input panels are now input pins (in order with the other inputs, named after the rows); "Rows are component inputs" can be turned off per panel to keep the old fixed switches
- Select input panels, Merge: one panel with all rows, spacing and wires kept; circuits that place this one keep their wires
- Cable ends plug in more often: bundling orders the wires by the part a side runs to, an end with only some wires on a part still plugs, an end placed by hand next to the pins plugs, and dragging an end near its part shows green rings and plugs it on drop
- Hex displays pass their four bits on (outputs on the right), so they can sit in the middle of a bus
- Design the box: move lamps, displays, the screen and the name on a component's box, draw lines, boxes, circles and text in six colours, size it, leave things off; every placed copy shows it

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-21 13:49:29 +02:00
Fabian @ Blax Software 4d0e32d678 A Loxone-style working aids: named signals, inverted inputs, a project check, values on cables, search, printable sheets; wire ends move by dragging
- Send signal / Use signal: name a signal (CLK, RESET) once and use it anywhere in the circuit without a wire; selecting one lights up all of them, a use with no sender shows dashed
- Inverted inputs: Alt + click an input (or the menu/settings) puts a bubble on it; it reads the signal inverted through one NAND, counted in every transistor total
- Check (Circuit tab): open inputs, parts that drive nothing, duplicate pin names, unsent or doubly sent signals, loops that never settle; click one to show it. Open inputs get an orange marker on the canvas. Components no other circuit uses are listed with a delete
- Cables show the number they carry (= 13 · 0x0D); hovering a wire tells where it runs and its value
- Ctrl+F finds parts, signals, panel rows, notes and components in every circuit, with where each component is used
- Ctrl+P prints the circuit as a sheet with a title block on white paper (or save as PDF); also as an SVG file
- + and − under a selected gate change its number of inputs; swaps keep bubbles in place
- Drag a wire by its end to move that end to another pin; drop a dragged wire on another wire to tap its signal or feed what it fed

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-21 13:26:59 +02:00
Fabian @ Blax Software f4e2c08658 A right-click menu for parts, wires and the canvas, "Wire them all to" as cards, plugged latches in plain greys
- Right click (or the menu key) shows what can be done with what is under the pointer: one part (open, rename, change to, inputs, colour, speed, panels, unpack, plug and unplug, cable colour), several parts (wire them all to with live preview, connect one by one, switches, change all, arrange, keep only, make a component), wires (bundle, colour, whole signal, straighten, remove cable) or empty canvas (paste here, add a part here, select all, fit, tidy, undo); right drag still moves the view
- "Wire them all to": a card per part, each fit a strip of its pins, and which wire goes where for the fit pointed at
- Plugged cable ends no longer look selected: grey connector, steel clips
- Icons named in menus are bundled for the browser too

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-21 12:33:30 +02:00
Fabian @ Blax Software 7ce8ffb9bc A wire a selection where it fits: green boxes over free pins in a row, and parts dropped onto a pin connect
- Select several lamps, output pins, switches or gates: every run of free pins they fit on (nearest parts first) shows as a green box; pointing along it picks the pins (S0+S1, S1+S2, ...) with a preview, a click wires them all top to bottom
- "Wire them all to" lists those fits, nearest first; the old pick-any-part stays under "Any part"
- Dragging a part so a free pin lands on (or a square from) a pin it can join shows a green ring and connects on drop; Alt places it without connecting
- A cable end only plugs in by itself when all its wires sit on the part; a name a part covers is hidden

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-21 12:16:26 +02:00
Fabian @ Blax Software 81a33b9b4b R slim cable ends: free ends are just their wires running into the ribbon, names only where nothing else shows them
- A free bundle or split has no box any more: each wire bends straight into its own lane of the cable, lit and coloured like the wire; a dashed outline shows on hover to grab it
- A wire's name shows next to a free end only when the part at the other end doesn't show it already (a switch or lamp of that name, a component pin)
- Names no longer widen a cable end, so its pins never move

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-21 11:59:17 +02:00
Fabian @ Blax Software 1741631ab0 A cable ends plug straight into parts and show their wire names, custom input panels with keys, colours and spacing
- A bundle or split whose wires all meet one part sits on its pins with a latch, moves with the part, and comes loose when dragged away; Ctrl+G plugs both ends in when it can
- Cable ends take the spacing of the pins they plug into, or a spacing you set
- Each wire of a cable carries a name (S0..S3, Cout), shown on free cable ends and as dimmed names on what they feed
- Bundles get "Attach input panel"; panel rows get a keyboard key, an on colour, space above and up/down order

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-21 11:51:45 +02:00
Fabian @ Blax Software 4fddb8cd34 A one-click cable bundling with smarter placement, BF unlink keeps the cable
- "Bundle into cable" (Ctrl+G) places both ends itself again: right after
  the sources on their middle row, right before the targets on theirs, so
  the wires keep their flow; backwards wires get a backwards cable, and an
  end steps aside when a part is in the way. "Place the ends yourself…"
  (Ctrl+Shift+G) keeps the two-click placement.
- "Unlink all" on a bundle or split removes only the wires going in or out;
  the cable between them stays.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-21 11:21:35 +02:00
Fabian @ Blax Software cf24578248 A box selection picks up the wires and cables it crosses
A box that touches no parts selects every wire it crosses, so dragging
across the wires between parts marks them for bundling. Right to left
(green box) selects everything touched, parts and wires; left to right over
parts keeps selecting only wires fully inside, so Delete stays safe.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-21 11:08:32 +02:00