In-browser Python

Run Python where the engineering happens.

Write and execute Python directly in Davinci with function selection, terminal output, and generated plots. Analysis stays beside the model instead of disappearing into a separate notebook or script folder.

Callable model attributes

Let model attributes call the analysis.

Use a code function directly in an attribute equation, pass connected model values as inputs, and keep the unit-aware result in the model. When the source changes, Davinci preserves the last result while showing that it needs to be recomputed.

Behavior and state simulation

Run the system through time, states, and transitions.

Use Python to advance modeled behavior with time loops, state activation, transitions, and monitored values. Davinci’s run view keeps code, active states, variables, and execution history together.

Compiled finite element analysis

Compile the setup. Explore the physics live.

Connect geometry to a reviewable boundary-condition program, inspect the mesh and applied conditions, then compile a Solution Space. Parameters re-solve fields and key results in the browser so teams can explore more than one frozen analysis point.

More ways to execute

From a line of code to a complete analysis workflow.

Author with agents, compare design tradeoffs, inspect dynamic response, preserve analysis artifacts, and know when a result needs attention.

Explore more with Davinci

Ask Davinci about its other capabilities.

How do I turn everything my team knows into better engineering decisions? Engineering knowledge management How do I modernize MBSE without giving up systems engineering rigor? Model based systems engineering Can mechanical design stay connected to the rest of my engineering work? Mechanical Design Can the electrical architecture and the physical board stay connected? Electrical design How can I tailor Davinci’s agents to the way my team engineers? Agentic customization Can Davinci fit our infrastructure, models, and security requirements? Enterprise management
All Features
In-browser Python

Move from an engineering question to executable analysis.

Python code objects open in a dedicated editor with familiar run controls. Select a callable function or run the complete script, then inspect standard output, errors, and generated plots in the adjacent terminal.

The Pyodide browser runtime keeps everyday analysis close to the work. Deployment-configured backend execution can support additional runtimes and heavier workloads without changing the code-object workflow.
Callable model attributes

Turn a code function into a connected model value.

An attribute equation can invoke a function as [code].method([inputs]). Davinci resolves UUID-anchored arguments, executes the linked Python or JavaScript function, and stores its scalar or unit-aware return as the attribute’s calculated value.

Dependencies remain visible after execution. Changes to the function or any referenced input mark the result stale without discarding the last computed value, making it clear when the model should be recomputed.
Behavior and state simulation

Exercise modeled behavior instead of describing it statically.

Python simulation code can activate a modeled starting state and advance it with time_loop. Transition conditions evaluate as time advances, state actions execute, and runtime assignments can drive the model values those conditions observe.

Monitoring makes execution inspectable. Follow variables, active states, messages, and timeline events in the run/debug view, then replay execution history to understand when a value or state changed.
Compiled finite element analysis

Move from one solve to an explorable Solution Space.

Set up the simulation from connected geometry and reviewable code. Davinci meshes the part, paints selections and boundary conditions for inspection, and records parameters and quantities of interest before compilation.

Compilation creates a live reduced-order Solution Space. Parameter changes re-solve fields and key results in the browser, while design-space sampling can compare many combinations without rebuilding the setup for every point.

Structural, thermal, and thermo-elastic workflows form the core compiled path. Harmonic response, modal dynamics, shock, flow, geometry axes, and other advanced workflows depend on deployment capabilities.
Agent-assisted authoring

Delegate code work without separating it from the project.

Agents use the real BuildCode and UpdateCode tools to author code objects, while RunObject executes a selected script, function, or action. Tool activity, outputs, and resulting model changes stay visible in the conversation.
Design tradeoffs

Turn sampled results into clear engineering choices.

Compiled simulations can sample combinations of parameters through the design-space workflow, including Latin-hypercube sampling. Each point carries its input settings and quantities of interest for comparison.

Teams can use Python to plot competing objectives and identify Pareto-efficient candidates from those sampled results. The Pareto view shown here represents an analysis output rather than a dedicated native multi-objective optimizer.
Circuit analysis

Analyze the circuit model with SPICE.

.spice code objects can bind to a Davinci circuit, combine the compiled netlist with analysis directives, and request waveforms through @plot. SPICE uses the backend ngspice runtime and therefore depends on backend execution being enabled for the deployment.
Dynamic response

Follow response across a frequency sweep.

Harmonic Solution Spaces add a frequency axis to the compiled model. Inspect frequency-response curves at the drive point, move through resonances, and animate the corresponding operating deflection shape on the geometry.

Harmonic and modal dynamics are advanced simulation capabilities and depend on the features enabled for a deployment.
Durable outputs

Bring useful runtime outputs back into the project.

Use file.save to preserve matplotlib figures, JSON, text, bytes, and other supported outputs instead of leaving them in a temporary execution environment. Saved artifacts can be referenced by later analyses, agents, and deliverables.
Result integrity

See when a trusted result is no longer current.

When callable source code changes, Davinci marks dependent attributes and test observations stale without discarding their last computed values. The Validation view and Linter stale pass expose affected chains so they can be recomputed deliberately.