Crosstwine Labs

Deliver reusable “code IPs”

The difference between “works on my machine” and high-quality, modular deliverables is… a lot of hard work. Our tools:

Packaging and delivery tools include:


Partition code into packages, small, goal-oriented, composable units of code which are developed and tests individually.

veda new-package invocation

Easily create new packages—including unit tests!

Optionally annotate packages with metadata such as description and author information, SKILL load order, and dependency information.

Use the SKILL API of our single-file package loader to easily manipulate your code collection.


Freeze pcells, PDK code, and CAD applications with a known version of their dependencies into inscrutable, obfuscated “blobs” with well-defined entry points.

It does not matter if app-A.cxt, callbacks-B and pcell-Z use a different and slightly incompatible version of the AwesomeUtility function—once bundled, they are properly isolated and only see the variant they were tested with.


Process “doc comments” and type annotations, and use a powerful code analysis engine to generate comprehensive static definitions of your distributable code IPs.

The result includes type information, which improves documentation and enables code intelligence features for downstream users/customers—even when source code is not provided.

See a basic example below.


Generate up-to-date, browsable HTML documentation for single files, packages or package collections, via the SKILL API or as part of your delivery process.

Optionally include hyperlinked, syntax-highlighted, source code for internal documentation or public packages.

Automatically generated documentation from an older version of Veda (does not include type information). Browse the complete set here.

Basic Condense Example

Here is a tiny bit of code for those so inclined. Given the following SKILL definitions:

defclass(MyToolClass () ((port) (zn)))

;; Entry point...
;; @param filename - Source data.
;; @param {fixnum} n - Iteration count.
;; @return The initialized tool.
procedure( MyIpFunction(filename n)
  let( ((port infile(filename)))
    makeInstance('MyToolClass ?port port ?zn n-1)

condense produces the following machine-readable bundle of static definitions (slightly trimmed-down for readability):

symbols ((MyIpFunction
          description (("Entry point..."))
          params ((filename
                   type (or symbol string)
                   summary "Source data.")
                   type fixnum
                   summary "Iteration count."))
          returns (nil
                   type MyToolClass
                   summary "The initialized tool.")))
types ((MyToolClass ...))

Note how we only specified the type of n, and that’s because n-1 implies fixnum||flonum—which is not constrained enough in our fictional example. Veda’s code intelligence features have been engineered to work well without extra… typing!