You can use the `bblego`

functions in order to create
custom backbones using various components. Please note that the `bblego`

functions currently only allow you to create tree-like backbones.

```
bblego(..., .list = NULL)
bblego_linear(
from,
to,
type = sample(c("simple", "doublerep1", "doublerep2"), 1),
num_modules = sample(4:6, 1),
burn = FALSE
)
bblego_branching(
from,
to,
type = "simple",
num_steps = 3,
num_modules = 2 + length(to) * (3 + num_steps),
burn = FALSE
)
bblego_start(
to,
type = sample(c("simple", "doublerep1", "doublerep2"), 1),
num_modules = sample(4:6, 1)
)
bblego_end(
from,
type = sample(c("simple", "doublerep1", "doublerep2"), 1),
num_modules = sample(4:6, 1)
)
```

- ..., .list
`bblego`

components, either as separate args or as a list.- from
The begin state of this component.

- to
The end state of this component.

- type
Some components have alternative module regulatory networks.

`bblego_start()`

,`bblego_linear()`

,`bblego_end()`

:`"simple"`

: a sequence of modules in which every module upregulates the next module.`"doublerep1"`

: a sequence of modules in which every module downregulates the next module, and each module has positive basal expression.`"doublerep2"`

: a sequence of modules in which every module upregulates the next module, but downregulates the one after that.`"flipflop"`

: a sequence of modules in which every module upregulates the next module. In addition, the last module upregulates itself and strongly downregulates the first module.

`bblego_branching()`

:`"simple"`

: a set of`n`

modules (with`n = length(to)`

) which all downregulate one another and upregulate themselves. This causes a branching to occur in the trajectory.

- num_modules
The number of modules this component is allowed to use. Various components might require a minimum number of components in order to work properly.

- burn
Whether or not these components are part of the warm-up simulation.

- num_steps
The number of branching steps to reduce the odds of double positive cells occurring.

A dyngen backbone.

A backbone always needs to start with a single `bblego_start()`

state and
needs to end with one or more `bblego_end()`

states.
The order of the mentioned states needs to be such that a state is never
specified in the first argument (except for `bblego_start()`

) before
having been specified as the second argument.

```
backbone <- bblego(
bblego_start("A", type = "simple", num_modules = 2),
bblego_linear("A", "B", type = "simple", num_modules = 3),
bblego_branching("B", c("C", "D"), type = "simple", num_steps = 3),
bblego_end("C", type = "flipflop", num_modules = 4),
bblego_end("D", type = "doublerep1", num_modules = 7)
)
```