Genetic Constructor and GSL – Best of Both Worlds

PhD’s and undergraduates spend countless hours designing plasmids. Between debating about which cloning strategy to use, designing primers, and copy-pasting thousands of base pairs, you probably spend more time designing than physically assembling your construct. This is bearable if you only have a handful of designs – but it creates a huge bottleneck if you want to analyze hundreds or thousands of assemblies at a time, not to mention it’s highly error prone. Genetic Constructor and GSL are addressing this problem – together they are the dynamic duo for synthetic biology: elegant visualization paired with powerful design abstraction.

Amyris, a biotech company located in Emeryville, CA , is facing the throughput challenge. They specialize in engineering microorganisms that take up carbon from renewable sources and convert it into valuable molecules. To do this, Amyris needs to push through many iterations of each genetic design and, with each iteration, they learn more about the organism and improve future development. So, how did Amyris make their design process faster and more efficient? Their answer is called the Genotype Specification Language (GSL). GSL is a genetic design language for synthetic biologists that can extract precise ranges of sequences from various host genomes, complete optimizations on the fly and design the assembly strategy as well as required primers for the scientist – all automatically. GSL is used everyday by scientists at Amyris and, after being published earlier this year, the language is now available to the entire scientific community through Genetic Constructor, a new CAD platform for genetic design from the Autodesk BioNano Group. GSL and Genetic Constructor provide a powerful genetic design algorithm paired with abstract, elegant visualization. Combined, these tools will help shift the genetic engineering bottleneck from design and construction to testing and learning.

Let’s start on the backend. What exactly is GSL? In short, GSL is a language that allows users to create DNA designs in simple yet precise syntax. It’s like programming in DNA! But not scary programming, we promise. If you’re a biologist reading this and shivering at the thought of needing to learn how to code to use GSL, fear not! GSL syntax was designed with common genetic notation in mind. Writing GSL is similar to what a biologist might write in a notebook and this familiarity has helped many scientists get on board with GSL, even if they have no programming background.
The key advantage of designing DNA constructs with GSL is that it moves you away from interacting with raw DNA sequences. How? Abstraction. For example, let’s say you want to knock out the native yeast gene HO, and replace it with an extra copy of the ADH1 gene being driven by a strong promoter like TDH3, and introduce a selectable marker, like URA3. Without any abstraction, the construct would be a massive string of ACTGs that fills your entire screen. Sure, you could add some helpful annotations to show where one piece ends and the next begins, but DNA sequences are not very human readable.
In GSL, you can describe that same construct, which is thousands of base pairs long, in just 5 words:

uHO ; pTDH3 ; gADH1 ; ### ; dHO
This Level 1 GSL syntax is a combination of common gene names and simple prefixes that indicate which part of each gene to use. The `###` syntax is GSL’s way of representing a selectable marker, the default being URA3. Pretty convenient already, but there is more: GSL offers a second level of abstraction. Another way to specify the above construct in GSL is:

gHO^ ; pTDH3>gADH1
Instead of encoding a design in terms of “these are all the pieces I want” (Level 1 GSL), this Level 2 syntax adds a bit more color onto the intended function of the construct where the “^” (a proxy for delta Δ) signals a gene knockout and the “>” indicates a promoter driving a gene. Both versions will translate into the exact same DNA but Level 1 gives the user a little more control over the exact part layout while Level 2 lends more freedom for GSL to decide on the layout. And you don’t even need to specify the marker; GSL will include one automatically!
Other features of GSL allow you to take custom slices from the genome, reorient parts in the reverse direction, introduce mutations, and insert custom slices of DNA. This flexibility enables users to create both high-level and intricate designs – combining abstraction with precision – while following basic design rules. At its core, GSL is a simple syntax of genes and prefixes, with extra modifiers if needed. By handling all low-level details from sequence to assembly strategy, GSL draws you away from thinking about ACTGs and frees you to focus your attention on the actual function and science behind your ideas.
With GSL, you gain a significant advantage in speed of design, ease of scalability, and quality of execution for genome engineering. The current GSL interface at Amyris is 100% focussed on writing and executing GSL, but it provides no immediate feedback about syntax correctness or the resulting construct. Without training, how would a scientist know what to type? How would they know if the GSL code they are composing would result in the intended construct? Most strain engineers at Amyris are not programmers but learn over time through internal tutorials, training, and tinkering. Immediate feedback and syntax suggestions would help tremendously with the learning curve – and those features are even more important if you don’t have all the Amyris resources available and/or have no prior coding experience. Even if you are familiar with coding, it is easy to forget syntax and you almost always start a new design based on prior work or a template. Genetic Constructor can help with all of these aspects by providing a layer of visualization to GSL. So what is Genetic Constructor and how specifically can it help?
Scalability is a rising challenge in genetic engineering as it has shifted from single plasmid manufacturing to rapid genome engineering. Design tools need to keep up. Genetic Constructor is designed to show you complex libraries and a multitude of modifications simultaneously within the browser. While the underlying sequence is still important and accessible, it is not at the center of the design process – the functional units of your design are. Operating at this higher functional level makes it easy for you to design and track many constructs at once.
On the backend, Genetic Constructor is based on a plugin architecture. That means you can connect your own computational tools to build or optimize constructs while making use of the existing UI. You can benefit from other published plugins and use them to build your own workflow for genetic design and step through any intermediate and final results visually. Whether you are a start-up or a big company – you can easily integrate your workflows into the Genetic Constructor and make it an integral part of your daily workflow. The GSL extension is a perfect example for this custom plugin workflow: Genetic Constructor provides a rich editing tool and construct visualization while GSL is driving the design.
To give you a taste of the GSL + Genetic Constructor environment in action, here is an example that demonstrates two constructs from a pathway to produce artemisinin, an antimalarial treatment, in yeast. To start, we’ll take a precise slice of the upstream region of the GAL1 gene and create a GSL variable encoding a bidirectional `pGAL1-10` promoter:
let pGAL1_10 = gGAL1[-668:-1]
This variable name can now be used in other constructs like a regular part by prepending its name with the “@” symbol. The first of our two constructs will use this bidirectional promoter to express ERG10 and ERG12 at the native HIS3 locus :
uHIS3 ; ### ; !mERG10 ; @pGAL1_10 ; mERG12 ; dHIS3
Did you notice the selectable marker `###` again? The second construct will overexpress ERG8 and MVD1 at the native LEU2 locus:
uLEU2 ; ### ; !mERG8 ; @pGAL1_10 ; mMVD1 ; dLEU2
It is easy to read and understand – and very efficient. Once you know the design you want to make, specifying it only takes a few seconds using Genetic Constructor and GSL in Google Chrome. Arranging the sequences manually could take hours.
This example also highlights the three big advantages of combining GSL and Genetic Constructor. Autocomplete and syntax highlighting will make it faster to write code and help you to get the code right the first time (1). Combining code with direct DNA output in the same tools provides immediate feedback allowing for quick iterations and fewer errors (2,3). And most importantly, saving of projects makes it super easy to reuse designs and strategies and automatically keeps an easily searchable record of prior work for you (4).
So there you have it: the dynamic duo of GSL and Genetic Constructor, taking on the challenges of DNA design for rapid genetic engineering. You can test drive this one-of-a-kind combination and experience the thrill of genetic engineering at a higher level of abstraction. Let your brain do science. We’ll take care of the rest!
Create your new Genetic Constructor account here – and go to your Extension Settings to enable GSL. Both Genetic Constructor and GSL are also open source projects and welcome contributions and feedback. You can find them here and here. Start an issue on the github repositories or contact us at geneticconstructor*at* or ewilson*at*

By Erin Wilson (Amyris) and Conny Scheitz (Autodesk)

Malte Tinnus

Malte Tinnus is a Senior Principal UX Designer at Autodesk Life Sciences, collaborating with world leading researchers to envision the paradigms and tools needed to understand and exploit the intersection of design and life.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s