Documentation

• Overview
• The slat and its sites
• Assembly generation
• Crossings and families
• Handle library
• Handle assignment
• Staged growth
• Free energy
• Sequences and order sheet
• Plates and picklists
• Editing
• Assembly code
• Accounts, saving and sharing
• Interaction reference
• Not built yet

Overview

Slatoland designs assemblies of one DNA origami part: an 8-helix-bundle slat, 345 nm long, folded from the p8064 scaffold. Slats stick to perpendicular slats through handles: short single-stranded tails on the 3′ ends of staples. You pick a resolution and an assembly style, and the app builds the lattice in 3D.

The pipeline is: resolution → lattice → crossing detection → handle assignment → sequence export → plate picklist. Each section below documents one stage.

The slat and its sites

The slat has eight helices in a ring. Handles leave from the four middle helices (1, 3, 5 and 7), which face outward 90° apart. Each of those helices is a row, and each row has 24 sites spaced 42 bp (14.28 nm) apart. That gives 96 places a handle can go.

Rows advance 90° around the slat in the order R1 → R2 → R3 → R4. Sites are numbered 1–24 from the low-offset end. Turn on Site labels and click a slat to see both on the model.

The staple at each site, its core sequence and its plate well come from the scadnano design in db/source and the source plate in app/assets/sequences (the IDT plate specification, which says what is in every well). After changing either, ruby script/build_slat_design.rb rebuilds public/data/slat_design.json, the one file both the browser and the server read. A slat has 195 staples: 99 are the same in every slat, and 96 sit at handle sites.

Assembly generation

The X, Y and Z inputs count lattice cells. There are two styles.

A slat spans 12 cells of the three-axis lattice. A line shorter than that gets one centred slat whose ends overhang. A longer line is tiled with slats end to end: Aligned puts the joints of neighbouring lines side by side, and Bricks shifts alternate lines by half a slat so the joints do not line up.

Every slat has an id such as x:3,5:0: its axis, the two coordinates of its line, and its position along that line.

Rendering. All slats are drawn by one instanced mesh, the rings around them by a second and all bond arms by a third, so the view costs three draw calls whatever the size. Above 30,000 slats the slat mesh drops to six sides without end caps.

Rings. The thin grey rings around each slat sit halfway between neighbouring handle sites, so the 23 rings divide a slat into its 24 sites and each handle sits in the middle of a segment. Lattices of more than about 2,800 slats keep every second ring, more than about 5,800 every fourth, and beyond about 12,800 slats the rings are left out.

Bonds. A bond is drawn as two arms, one reaching out from each slat, that meet halfway between them. Both are in the colour of the bond's handle; the arm of the slat that carries the antihandle is the darker one. A handle that faces no other slat is drawn as a single arm.

Spacing caveat. The three-axis lattice only closes if crossing slats are 14.28 nm apart, which leaves about 7 nm between slat surfaces. The handle and spacer have to span that. The spacer is a library setting; check it before ordering.

Crossings and families

A crossing is a place where a site of one slat faces a site of a perpendicular slat. Detection computes the contact point of every site on every row (half the centre-to-centre gap out from the slat axis) and pairs up points that coincide. Each crossing is found once.

Crossings are grouped into families by the axes of the two slats: x–y, x–z and y–z. A full 12 × 12 × 12 lattice has 432 slats and 9,936 crossings, 3,312 in each family; an interior slat makes 48 bonds.

Sites with no partner keep their bare core staple.

Handle library

A handle is a short sequence added to a staple's 3′ end after a spacer. One slat of a crossing carries the handle and the other carries its reverse complement, the antihandle.

The library generator picks handles that are similar in strength and far apart in sequence:

• GC content between 25% and 60%, and no run of one base longer than three.
• Duplex ΔG inside the window you set.
• At least three mismatches against every other handle, against every antihandle, and against its own reverse complement.

Generation is deterministic: the same settings and seed number give the same library. You can also choose the 12 handles that are already on the plate.

Handle assignment

Every crossing gets one library handle. The assignment decides which slat docks where, so the goal is orthogonality: slats that are not meant to pair should not be able to.

Overlap

Two free slats can lie side by side. If several handles on one line up with matching antihandles on the other, they stick. The overlap of a pair is the largest number of such matches, taken over all 16 pairs of rows, parallel and antiparallel orientations, and every shift along the slat. Two slats that are meant to cross always have an overlap of at least 1, from their own bond.

You set two ceilings: one for slats in the same growth stage and one for slats in different stages.

Which side carries the handle, and pools

With One shared pool every crossing draws from the whole library. That gives each family more handles to choose from but allows same-axis pairing.

Search

1. Placement. Crossings are visited in random order. Each takes the handle that leaves the lowest worst-case overlap, breaking ties by how crowded the affected alignments are.
2. Repair sweeps. Every crossing that sits in a worst-case alignment is lifted out and re-picked. Sweeps repeat until the limits are met, a sweep leaves the worst case no better, or the sweep budget runs out. On small lattices, where it costs next to nothing, sweeps carry on past the limits to tighten the result further.
3. Random starts. If the limits are not met, the whole procedure runs again from a different random order, up to the number of starts; the best result wins.

The dialog opens with a library size that suits the lattice: about one and a half handles per bond on the busiest slat, which is 96 handles for the full 12 × 12 × 12 lattice. Smaller libraries repeat handles too often to meet the default limits.

The search runs in a web worker and can be cancelled. The full 12 × 12 × 12 lattice with 96 handles takes around ten seconds. A library that is too small takes much longer, because every start runs all its sweeps before giving up; use fewer candidates per crossing to make that faster.

If the limits are not met you still get the best assignment found, marked as such. Use a larger library, raise the limits, add sweeps, or split the build into more stages.

Scores

The specificity score is 100 × (1 − worst overlap ÷ mean bonds on arrival). Each bond forms when the later of its two slats arrives, so on average a slat arrives with half its bonds. The Overlap colour mode paints every slat by its worst overlap, and clicking a slat lists its worst partners.

Handle assignments are saved with the assembly, so reopening it restores them without running the search again.

Staged growth

Staged growth is Slatoland's version of a hierarchical assembly. Slats are split into pools that are added one after another.

• Depth is how far a slat's line is from the corner the structure grows from.
• Seed depth n puts every slat of depth below n into stage 0, the seed. A seed depth of 0 means no seed.
• Growth stages splits the rest into that many pools of similar size, in order of depth.

The Growth preview slider shows the structure after each stage. The Analysis tab reports, per stage, how many bonds a slat has to slats already in place when it arrives.

Stages matter to handle assignment because slats in different stages are never free in solution together, so their overlap limit can be looser than the limit within a stage.

Free energy

Each handle's duplex ΔG is computed from nearest-neighbour parameters at 37 °C and 1 M NaCl (SantaLucia 1998), in kcal/mol. The window in the library settings keeps handles of similar strength. After assignment the result shows the mean and spread of the summed handle energy per slat; a tight spread means slats are bound about equally.

These values rank handles against each other. They are not corrected for magnesium or for the origami context.

Sequences and order sheet

Slats with identical handles are one species and share one folding reaction. Sequences writes a CSV with every oligo of every species: 195 rows each. At a site with a handle, the core staple is replaced by core + spacer + handle.

Handle staples are named after their core staple and handle: ST3[85]1[82]_h07 carries handle h07, and ST5[88]3[84]_h07c carries its antihandle.

Order sheet lists each distinct handle staple once, with how many species and slats use it. Staples that match an oligo already on the plate are marked on hand and keep their well. The rest get a fixed library-plate address:

plate   SLAT_R<row><H|A>_<block>     H = handle, A = antihandle
column  site 1–24
row     A–P, sixteen library handles per plate

The address depends only on the row, site and handle, so an order sheet written today and a picklist written later always agree.

Plates and picklists

The Plates tab models 96-, 384- and 1536-well destination plates. Add to plate puts one species per well, filling the next free wells and opening new plates when one is full. You can add all stages or one stage at a time.

Export picklist sends the plates to the server, which writes an Echo CSV with source plate, source well, destination plate, destination well and volume per row:

• Every staple is its own 50 nL transfer from its well on the source plate, so a well takes 195 transfers.
• Each of the 99 shared core staples and each bare site staple comes from its well on that plate. A site with a handle takes the handle staple from the same plate if it is there, and otherwise from its library-plate address.
• Core staples can be switched to Pooled mix: the 99 shared staples then come as one 4,950 nL transfer from SLAT_CORE_MIX, a pre-mixed plate that is not the source plate and has to be prepared first.
• With scaffold on, each well gets 8.8 µL from SCAFFOLD_MIX in equal drops, drawn round-robin from rows A–H (chloride) or I–P (acetate).

Save synthesis run stores the current plates against your account; the Synthesis page shows each run's plate maps and well contents.

Editing

• Deleting slats. Hover a slat and press Delete. Deleted slats are stored with the design and left out of crossing detection, so handles must be assigned again. Restore all brings them back.
• Editing one bond. Click a handle to see both slats, the site and row on each, and the sequences. You can change its handle or remove the bond, which leaves bare core staples at that crossing.
• Import and Export round-trip the whole design as JSON: parameters, stages, deleted slats, library and handles.
• Save image downloads the current view as a PNG.

Assembly code

The Assembly code panel is on the right of the designer. On a wide window it is open beside the 3D view; on a narrower one it is folded to a dark tab on the right edge of the window, and slides over the page when opened. Assembly code under Tools in the sidebar opens it too, and the tab folds it away again. It shows the design as JSON and builds a design from JSON, so a structure can be written, edited or pasted as text.

• Load current writes the design on screen into the panel.
• Open file… reads a .json file into the panel, and Examples loads one that ships with the app.
• Build from code replaces the design on screen with the one the code describes, then reports what it built. If the code cannot be built, the message says which slat or field is wrong and the design on screen is left as it was.
• Copy and Download take the text out again. A design file written by Export design can be built from as well.

Code describes one of two things. A lattice is a resolution, exactly as on the Design tab:

{
  "slatoland": 1,
  "name": "Small lattice",
  "lattice": { "style": "lattice3d", "cells": [4, 4, 4], "longLines": "aligned", "stages": 2, "seedDepth": 1 },
  "deleted": ["x:0,0:0"],
  "library": { "spacer": "TT", "handles": ["GACAATC", "CGTTGCT"] },
  "handles": { "x:0,1:0": { "1": { "1": "h01", "3": "h02*" } } }
}

A list of slats places slats one by one, which is how a structure that is not a regular lattice is made:

{
  "slatoland": 1,
  "name": "Two crossed slats",
  "library": "plate",
  "gap": 11,
  "slats": [
    { "id": "a", "at": [0, 0, 0], "axis": "+x", "row1": "+z",
      "handles": { "1": { "3": "h01" } } },
    { "id": "b", "at": [2, 2, 0], "lift": [0, 0, 1], "axis": "-y", "row1": "-x",
      "handles": { "2": { "3": "h01*" } } }
  ]
}

A bond forms where a site of one slat faces a site of a perpendicular slat one gap away, and one carries a handle and the other its antihandle. After a build the panel counts the bonds and lists what will not hold: facing sites whose handles do not pair, handles that face no slat (drawn as single arms), slats that pass through each other, and slats that touch nothing. It also says how many of the handle staples are already on your plate.

A structure built from code shows as Built from code in the Assembly style menu and has no resolution to change; choosing a lattice style there goes back to a lattice. Deleting a slat keeps the handles written for the others. Saving, sharing, sequences, plates and picklists work as for a lattice, and Assign handles can replace the written handles with a searched set.

Corner frame. The examples are a 23-slat floor with a wall standing on it, made only from the 24 handle staples on the ordered plate. In the original each slat uses 6 of the 12 extensions on a face, in a combination no other slat has, and the slat where floor and wall meet uses both faces. On that plate the handle at a site pairs with the antihandle at the same site, so two slats that use the same six sites on facing rows could also lie side by side: the overlap check finds five such pairs, which is why its score is 0.

Levels of interconnection. Three more examples are the same frame with fewer bonds, for asking how much interconnection an assembly needs (at a given magnesium level, with or without a seed). No slat moves. Each level keeps one bond fewer on every slat face, and only takes bonds away from the level above, so the series differs in nothing but how interconnected it is.

In every level the frame is still one piece and all 23 slats are different monomers, so the four frames take 92 folding reactions, none shared, and fit one 96-well plate: build each, choose Add to plate with Current plate, and export one picklist. A crossing whose bond was taken away stays a crossing: the header then shows fewer bonds than crossings, and hovering a slat shows both. script/corner_frames.mjs writes the four files and holds the search that chose which bonds to keep.

Larger corner frames. A slat is bonded once to every slat it crosses, so a slat with more bonds is a slat that more slats cross. In the 23-slat frame 6 slats cross every used face and every crossing is already a bond, so more bonds need more slats. Three more examples are the same floor and wall with 7, 8 or 9 slats each way, still made only from the handle staples on the ordered plate. The slats in the middle of the floor and of the wall are crossed by as many slats as the frame has each way, and every crossing is a bond. The outermost slats are still bonded to 6: on this plate no layout gives every slat more. The slat that floor and wall share has 12, six on each face.

In each frame all slats are different monomers. Two sheets of one size laid out the same way would be built from the same monomers, so each frame leaves a few positions empty, which costs 1, 2 and 4 bonds against the most its two sheets could hold; script/large_corners.mjs holds the search that chose the layouts and writes the files. The three frames take 93 folding reactions and fit one 96-well plate (65 of the monomers are different, because some slats are the same in two or all three frames). The original with the 7 and the 8 frame takes 81. As in the sheets below, more bonds cost as much side-by-side overlap, and the score stays 0.

Sheets. The sheet examples are single two-layer sheets, flat rather than three-dimensional, also made only from the handle staples on the ordered plate: rows along x under diagonals along y, each slat starting two sites further along than the one before. The slats in the middle are crossed by as many slats as the sheet has each way, up to all 12 extensions of a face in the 12 × 12 sheet, and every crossing is a bond. The outermost row and diagonal are still bonded to 6.

More bonds cost as much side-by-side overlap. A row and a diagonal that carry extensions at the same sites could pair along their length instead of crossing, so the worst overlap of a sheet equals the most bonds any of its slats has, and the score stays 0. The three sheets take 60 folding reactions; 32 of the monomers are different, because some slats are the same in two or all three sheets. script/sheets.mjs writes the files.

Accounts, saving and sharing

Sign-in is email and password. The first account is open; after that a new account needs a member's referral code, which expires after 30 days and can be regenerated on the profile page.

Without an account you can change the lattice, delete slats and browse the catalog. Handle assignment, sequence export, plates, picklists and saving ask you to sign in.

• Save stores the assembly, handles included, and puts you on its /assembly/:id address. Saving again updates it.
• Catalog lists your assemblies and those others have published. Publish or unlist from the card.
• Share link makes a frozen read-only copy at /shared/<token>. The viewer can open their own copy in the designer.

Interaction reference

Not built yet

These Boxoland features are planned for the second pass and are not in this version: nanoparticle and cargo placement, DNA-PAINT probes and patterns, MEEP export, placing saved assemblies next to each other, and multi-view image export.

Back to the designer