openscvx 0.5.3.dev39__tar.gz → 0.5.3.dev40__tar.gz

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/.github/workflows/_docs.yml

@@ -61,6 +61,7 @@ jobs:
       run: |
         uv pip install --system "mkdocs-material[imaging]" mkdocstrings-python
         uv pip install --system mkdocs-gen-files mkdocs-literate-nav mkdocs-section-index
+        uv pip install --system mkdocs-git-revision-date-localized-plugin
         uv pip install --system mike
 
     - name: Install package

openscvx-0.5.3.dev40/CITATION.cff

@@ -0,0 +1,42 @@
+cff-version: 1.2.0
+message: >-
+  If you use OpenSCvx in your research, please cite the software and the
+  preferred citation (Hayner et al., IEEE RA-L 2025) below.
+title: "OpenSCvx: Nonlinear Trajectory Optimization via Successive Convexification"
+abstract: >-
+  OpenSCvx is an open-source Python library for nonlinear trajectory optimization
+  built on successive convexification (SCvx). It compiles a composable symbolic
+  problem definition into JAX/CVXPY code and solves nonconvex trajectory problems
+  through sequential convex programming.
+type: software
+authors:
+  - family-names: Hayner
+    given-names: Christopher R.
+  - family-names: Norris
+    given-names: Griffin
+repository-code: "https://github.com/OpenSCvx/OpenSCvx"
+url: "https://openscvx.github.io/OpenSCvx/"
+license: Apache-2.0
+keywords:
+  - trajectory optimization
+  - successive convexification
+  - optimal control
+  - JAX
+  - Python
+preferred-citation:
+  type: article
+  title: >-
+    Continuous-Time Line-of-Sight Constrained Trajectory Planning for
+    6-Degree of Freedom Systems
+  authors:
+    - family-names: Hayner
+      given-names: Christopher R.
+    - family-names: Carson III
+      given-names: John M.
+    - family-names: Açıkmeşe
+      given-names: Behçet
+    - family-names: Leung
+      given-names: Karen
+  journal: IEEE Robotics and Automation Letters
+  year: 2025
+  doi: 10.1109/LRA.2025.3545299

{openscvx-0.5.3.dev39/openscvx.egg-info → openscvx-0.5.3.dev40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.5.3.dev39
+Version: 0.5.3.dev40
 Summary: A general Python-based successive convexification implementation which uses a JAX backend.
 Author-email: Chris Hayner and Griffin Norris <haynec@uw.edu>
 License: Apache Software License
@@ -214,7 +214,7 @@ Check out the OpenSCvx documentation:
 
 - [Users Guide](https://openscvx.github.io/OpenSCvx/latest/UsersGuide/00_introduction/)
 - [API Reference](https://openscvx.github.io/OpenSCvx/latest/Reference/)
-- [Examples overview](https://openscvx.github.io/OpenSCvx/latest/examples/)
+- [Examples overview](https://openscvx.github.io/OpenSCvx/latest/Examples/)
 
 ### Running the Examples
 

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/README.md

@@ -167,7 +167,7 @@ Check out the OpenSCvx documentation:
 
 - [Users Guide](https://openscvx.github.io/OpenSCvx/latest/UsersGuide/00_introduction/)
 - [API Reference](https://openscvx.github.io/OpenSCvx/latest/Reference/)
-- [Examples overview](https://openscvx.github.io/OpenSCvx/latest/examples/)
+- [Examples overview](https://openscvx.github.io/OpenSCvx/latest/Examples/)
 
 ### Running the Examples
 

openscvx-0.5.3.dev40/docs/Foundations/constraint_reformulation.md

@@ -0,0 +1,77 @@
+---
+title: Constraint Reformulation (CTCS)
+description: >-
+  How OpenSCvx enforces path constraints continuously in time by integrating an
+  augmented penalty state, rather than only at the discretization nodes.
+---
+
+# Isoperimetric Constraint Reformulation
+
+![CTCS_dark]{ align=right width="60%" }
+![CTCS_light]{ align=right width="60%" }
+
+Path constraints are meant to hold for *all* time, but a node-based
+transcription only checks them at the discretization nodes — leaving the solution
+free to violate them *between* nodes. OpenSCvx closes this gap with
+**continuous-time constraint satisfaction (CTCS)**: it reformulates a path
+constraint as an integral condition on an augmented state, so satisfying it at
+the nodes guarantees satisfaction throughout the interval.
+
+## The augmented penalty state
+
+Write each path constraint in canonical form $g(x, u) \le 0$. For a group of
+CTCS constraints, OpenSCvx adds one augmented state $y$ whose derivative
+accumulates a non-negative penalty of the constraint violations:
+
+$$
+\frac{\mathrm{d}y}{\mathrm{d}\tau}
+  = s(\tau)\, \sum_j \mathrm{penalty}\big(g_j(x, u)\big),
+$$
+
+where the default penalty is the squared ReLU $\max(0, g_j)^2$ (Huber and smooth
+ReLU are also available), and $s$ is the [time-dilation](time_dilation.md)
+factor. Because the integrand is non-negative, $y$ is monotonically
+non-decreasing and accumulates *any* violation occurring between nodes.
+
+Enforcing $y \equiv 0$ then drives every penalty — and hence every constraint —
+to zero continuously. In practice the convex subproblem (i) resets $y$ to $0$ at
+the start of each enforcement interval and (ii) bounds the per-segment increment,
+
+$$
+y_0 = 0, \qquad |y_k - y_{k-1}| \le y_{\max},
+$$
+
+so a small $y_{\max}$ makes the between-node violation provably small. This is
+the isoperimetric-style reformulation: a bounded integral of the violation stands
+in for an infinite family of pointwise constraints.
+
+## Declaring CTCS constraints
+
+Wrap any path constraint with `ox.ctcs`, or call `.over(...)` on a constraint to
+restrict it to a node interval:
+
+```python
+import openscvx as ox
+
+constraints = [
+    ox.ctcs(state <= state.max),
+    ox.ctcs(state.min <= state, penalty="huber"),
+    (distance >= obstacle_radius).over((0, N)),
+]
+```
+
+Constraints sharing an enforcement interval are grouped onto one augmented state;
+different intervals get separate states. The bound $y_{\max}$ is the constraint's
+`licq_max` (default $10^{-4}$); tighten it for stricter between-node enforcement.
+After solving, the achieved continuous-time violation is reported as
+`results.ctcs_violation`.
+
+## Related reading
+
+- [Optimal Control Problem](ocp.md) — where the CTCS reset-and-bound constraints
+  enter the convex subproblem.
+- [Time Dilation](time_dilation.md) — the $s$ factor that also scales the CTCS
+  dynamics.
+
+[CTCS_dark]: ../assets/images/ctcs_dark.png#only-dark
+[CTCS_light]: ../assets/images/ctcs_light.png#only-light

openscvx-0.5.3.dev40/docs/Foundations/control_parameterization.md

@@ -0,0 +1,70 @@
+---
+title: Control Parameterization
+description: >-
+  Zero-order-hold (ZOH) versus first-order-hold (FOH) control parameterization
+  between nodes in OpenSCvx, and how to set it per problem or per control.
+---
+
+# Control Parameterization
+
+The optimization variables live at discrete **nodes**, but the dynamics are
+continuous, so OpenSCvx must decide how the control behaves *between* nodes. This
+choice is the **control parameterization**, and it determines how the control
+value on a segment is reconstructed from the node values during discretization.
+
+## Zero-order versus first-order hold
+
+Across a segment from node $k$ to node $k+1$, the control is interpolated as
+
+$$
+u(\tau) = u_k + \beta(\tau)\,\big(u_{k+1} - u_k\big),
+$$
+
+where $\beta$ ramps from $0$ to $1$ over the segment. The two standard choices
+differ only in $\beta$:
+
+- **Zero-order hold (ZOH):** $\beta = 0$, so $u(\tau) = u_k$ is held constant
+  across the segment. Only the current node couples into the segment dynamics, so
+  discretization produces a single control transition matrix $B_d$.
+- **First-order hold (FOH):** $\beta$ blends linearly from $0$ to $1$, so the
+  control is piecewise-linear and continuous across nodes. Both endpoints couple
+  in, producing two transition matrices, $B_d$ (current node) and $C_d$ (next
+  node).
+
+FOH gives a smoother, continuous control profile at the cost of an extra
+transition matrix per segment; ZOH is cheaper and matches hardware that applies a
+piecewise-constant command.
+
+## Choosing a parameterization
+
+The default parameterization is **FOH**. Set it globally through the
+discretizer:
+
+```python
+import openscvx as ox
+
+problem = ox.Problem(
+    dynamics, ...,
+    discretizer={"dis_type": "ZOH"},   # or "FOH" (default)
+)
+```
+
+`dis_type` also accepts a per-control sequence (e.g. `["FOH", "ZOH", "FOH"]`) to
+mix parameterizations across control channels.
+
+A per-control setting overrides the discretizer default, so you can request a
+specific hold on the control that needs it:
+
+```python
+thrust = ox.Control("thrust", shape=(3,), parameterization="ZOH")
+```
+
+The time-dilation control added for [free-final-time problems](time_dilation.md)
+is parameterized as ZOH.
+
+## Related reading
+
+- [Exact Discretization](discretization.md) — how the chosen hold enters the
+  discretized transition matrices.
+- [Time Dilation](time_dilation.md) — the dilation control and its
+  parameterization.

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/Foundations/discretization.md

@@ -1,7 +1,11 @@
-# Exact Discretization
+---
+title: Exact Discretization
+description: >-
+  How OpenSCvx discretizes and linearizes continuous-time dynamics by
+  integrating an augmented state vector to build the ZOH/FOH transition matrices.
+---
 
-!!! Warning
-    This page is still under development :construction:.
+# Exact Discretization
 
 ``` py title="dVdt.py"
 def dVdt(self,

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/Foundations/ocp.md

@@ -1,6 +1,11 @@
+---
+title: Optimal Control Problem
+description: >-
+  The convex subproblem OpenSCvx solves each SCP iteration: variables, affine
+  scaling, discretized dynamics, virtual control, and trust-region costs.
+---
+
 # Optimal Control Problem
-!!! Warning
-    This page is still under development :construction:.
 
 The underlying convex subproblem is posed in the following general form. 
 

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/Foundations/scvx.md

@@ -1,6 +1,12 @@
-# What is Succesive Convexification?
-!!! Warning
-    This page is still under development :construction:.
+---
+title: What is Successive Convexification?
+description: >-
+  Successive convexification (SCvx) solves nonconvex trajectory optimization by
+  repeatedly linearizing the problem and solving the convex subproblem until
+  convergence.
+---
+
+# What is Successive Convexification?
 
 *Successive Convexification* is an approach to solve infinite dimensional nonconvex trajectory optimization problems. It works by *successively* convexifying or linearizing a problem and solving the convex subproblem. The solution to the convex subproblem is then used to update the original problem, and the process is repeated until convergence.
 
@@ -9,7 +15,7 @@
 
 
 ## Problem Formulation
-In this repository, the user will likely find it most useful specify there problem in the Mayer Form order to take full advantage of the features of this repo, but not worry this is quite easy.
+In this repository, the user will likely find it most useful to specify their problem in the Mayer Form in order to take full advantage of the features of this repo, but do not worry, this is quite easy.
 
 $$
 \begin{align}

openscvx-0.5.3.dev40/docs/Foundations/time_dilation.md

@@ -0,0 +1,82 @@
+---
+title: Time Dilation
+description: >-
+  How OpenSCvx handles free-final-time and minimum-time problems by optimizing a
+  time-dilation control on a fixed normalized-time grid.
+---
+
+# Time Dilation
+
+*Time dilation* is how OpenSCvx supports **free-final-time** problems — including
+minimum-time problems — on a fixed transcription grid. Rather than optimize over
+physical time directly, OpenSCvx discretizes the trajectory on a **normalized
+time** $\tau \in [0, 1]$ with fixed node spacing, and lets the solver stretch or
+compress physical time through an extra control.
+
+## Normalized time and the dilation factor
+
+Let $\tau$ be normalized time and $t$ physical time. Their relationship is
+governed by a scalar **time-dilation factor** $s(\tau)$:
+
+$$
+\frac{\mathrm{d}t}{\mathrm{d}\tau} = s(\tau).
+$$
+
+Because every physical derivative is taken with respect to $t$, expressing the
+dynamics on the $\tau$ grid scales them by $s$:
+
+$$
+\frac{\mathrm{d}x}{\mathrm{d}\tau}
+  = \frac{\mathrm{d}x}{\mathrm{d}t}\,\frac{\mathrm{d}t}{\mathrm{d}\tau}
+  = s(\tau)\, f\big(x(\tau), u(\tau)\big).
+$$
+
+OpenSCvx treats time as a state (with $\mathrm{d}t/\mathrm{d}\tau = s \cdot 1$)
+and $s$ as an ordinary per-node control. Making $s(\tau)$ a decision variable is
+what turns a fixed-grid transcription into a free-final-time problem: a larger
+$s$ spends more physical time per grid interval, so the solver can slow down near
+constraint boundaries and speed up elsewhere. The dilation multiplication is
+applied symbolically when the problem is built, so JAX autodiff produces the
+correct Jacobians — including $\partial f/\partial s = f$ — automatically.
+
+## Declaring a free final time
+
+Free and minimum-time problems are declared through the `ox.Time` object passed
+to `ox.Problem`. The `final` field accepts the same boundary markers as any
+state — `"free"`, `"minimize"`, or `"maximize"` — so a minimum-time problem is
+simply a free final time that is minimized:
+
+```python
+import openscvx as ox
+
+# Minimum-time: final time is free and minimized.
+time = ox.Time(initial=0.0, final=("minimize", tf_guess), min=0.0, max=800.0)
+
+problem = ox.Problem(dynamics, ..., time=time)
+```
+
+OpenSCvx augments the problem with a dedicated dilation control automatically. By
+default its per-node bounds are $0.3\,t_f \le s \le 3\,t_f$; you can override
+them, seed a dilation guess, or force a uniform physical time step:
+
+```python
+time = ox.Time(
+    initial=0.0,
+    final=time_final,
+    guess=time_guess,
+    time_dilation_min=time_dilation_min,
+    time_dilation_max=time_dilation_max,
+    uniform_time_grid=False,  # allow s to vary node to node
+)
+```
+
+Setting `uniform_time_grid=True` adds equality constraints forcing $s$ equal
+across all nodes, recovering a single free scalar duration with evenly spaced
+physical time steps.
+
+## Related reading
+
+- [Exact Discretization](discretization.md) — how the dilated dynamics are
+  integrated on the $\tau$ grid.
+- [Control Parameterization](control_parameterization.md) — how controls,
+  including the dilation control, are interpolated between nodes.

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/UnderTheHood/batching_jit_grad.md

@@ -1,3 +1,9 @@
+---
+description: >-
+  How OpenSCvx's `solve_jax()` entry point runs the SCP loop as a pure JAX
+  `lax.while_loop` so solves compose with `jax.vmap`, `jax.jit`, and `jax.grad`.
+---
+
 # Batching, JIT, and Grad with `Problem.solve_jax()`
 
 `Problem` exposes two solve entry points. `solve()` is the familiar

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/UnderTheHood/custom_algorithms_autotuners.md

@@ -1,3 +1,9 @@
+---
+description: >-
+  How to swap OpenSCvx's SCP iteration and penalty-weight schedule by subclassing
+  the `Algorithm` and `AutotuningBase` bases without forking the solver.
+---
+
 # Custom Algorithms and Autotuners
 
 OpenSCvx solves through a pluggable SCP loop: an **algorithm** owns the

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/UnderTheHood/lowering_architecture.md

@@ -1,3 +1,9 @@
+---
+description: >-
+  How OpenSCvx lowers symbolic problem definitions into executable JAX and CVXPy
+  code — the second of its preprocessing, lowering, solving, and post-processing phases.
+---
+
 # Lowering Architecture
 
 This document explains how OpenSCvx converts symbolic problem definitions into executable code for optimization.

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/UnderTheHood/vectorization_and_vmapping.md

@@ -1,3 +1,9 @@
+---
+description: >-
+  How OpenSCvx unifies per-node State and Control objects into monolithic vectors and
+  applies `jax.vmap` to evaluate dynamics and nonconvex constraints across decision nodes in parallel.
+---
+
 # Vectorization and Vmapping Across Decision Nodes
 
 This page explains how OpenSCvx internally processes symbolic problem definitions into vectorized JAX computations. After symbolic preprocessing and augmentation (which you've likely seen in basic usage), the library creates unified state/control vectors and applies JAX's `vmap` to evaluate dynamics and non-convex constraints across decision nodes in parallel.

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/UsersGuide/00_introduction.md

@@ -1,3 +1,8 @@
+---
+description: >-
+  A progressive introduction to trajectory optimization with OpenSCvx, building from a first model to representative real-world problems.
+---
+
 # Users Guide
 
 Welcome to the OpenSCvx Users Guide. This section aims to provides a progressive and useful introduction to trajectory optimization with OpenSCvx, starting from first principles and building toward complex, representative problems.

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/UsersGuide/01_hello_world_brachistochrone.md

@@ -1,3 +1,8 @@
+---
+description: >-
+  A hello-world OpenSCvx tutorial that solves the brachistochrone minimum-time problem: states, controls, dynamics, time, and CTCS constraints.
+---
+
 # 01 Hello Brachistochrone
 
 In this _hello world_ tutorial we will introduce the reader to the fundamental concepts and API needed to define and solve a problem using OpenSCvx as well as how the results can be accessed.

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/UsersGuide/02_drone_racing_constraints.md

@@ -1,3 +1,8 @@
+---
+description: >-
+  Model a 3-DOF drone racing through gates in OpenSCvx using nodal constraints, .at()/.over()/.convex(), and keyframe initialization.
+---
+
 # 02 Drone Racing: Constraints and 3-DOF Dynamics
 
 In this tutorial we build on the concepts from [Hello Brachistochrone](01_hello_world_brachistochrone.md) to tackle a more interesting problem: time-optimal drone racing through gates.

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/UsersGuide/03_obstacle_avoidance_vmap.md

@@ -1,3 +1,8 @@
+---
+description: >-
+  Solve 6-DOF obstacle avoidance in OpenSCvx using parameters and ox.Vmap to batch many obstacles without hand-written Python loops.
+---
+
 # 03 Obstacle Avoidance: 6-DOF Dynamics, Parameters, and Vmap
 
 In this tutorial we tackle a more realistic drone control problem: navigating through obstacles with full 6-DOF rigid body dynamics.

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/UsersGuide/04_viewpoint_constraints.md

@@ -1,3 +1,8 @@
+---
+description: >-
+  Add continuous line-of-sight viewpoint constraints to a 6-DOF OpenSCvx trajectory optimization problem.
+---
+
 # 04 Looking Back: Viewpoint Constraints
 
 In this tutorial we will combine what we have learned in the past several exercises while introducing a new viewplanning constraint formulation.

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/UsersGuide/05_visualization.md

@@ -1,3 +1,8 @@
+---
+description: >-
+  Plot and inspect OpenSCvx results with Matplotlib and interactive Viser visualization.
+---
+
 # 05 Visualizing Results
 
 Once you've solved a trajectory optimization problem, you'll want to see the results. OpenSCvx provides two complementary visualization systems:

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/UsersGuide/06_logic.md

@@ -1,3 +1,9 @@
+---
+noindex: true
+search:
+  exclude: true
+---
+
 # 06 Dubin's Car: Conditional Statements and Signal Temporal Logic
 
 !!! Warning "Work In Progress"

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/UsersGuide/07_lie.md

@@ -1,3 +1,8 @@
+---
+description: >-
+  Optimize a 7-DOF redundant arm pick-and-place in OpenSCvx using Lie-group forward kinematics on SE(3) and algebraic propagated states.
+---
+
 # 07 Multi-Link Arms: Lie Algebra and Propagated States
 
 In this tutorial we leave the world of free-flying rigid bodies and step into manipulation.

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/UsersGuide/08_mpcc.md

@@ -1,3 +1,8 @@
+---
+description: >-
+  Build receding-horizon model predictive contouring control (MPCC) in OpenSCvx to track a reference path through gates at speed.
+---
+
 # 08 Receding Horizon Drone Racing: Model Predictive Contouring Control
 
 In this tutorial we step away from single-shot trajectory optimization and into the world of receding-horizon control.

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/UsersGuide/09_mjx_dynamics.md

@@ -1,3 +1,8 @@
+---
+description: >-
+  Drive OpenSCvx trajectory optimization with MuJoCo MJX dynamics for contact-rich robotic systems.
+---
+
 # 09 MuJoCo MJX Dynamics
 
 In earlier tutorials we wrote dynamics by hand as symbolic expressions. Many real systems already have a MuJoCo model — articulated robots, cartpoles, quadrotors — and re-deriving those equations is tedious and error-prone.

openscvx-0.5.3.dev40/docs/changelog.md

@@ -0,0 +1,20 @@
+---
+title: Changelog
+description: >-
+  Release history for OpenSCvx. Each tagged release publishes versioned documentation and a
+  detailed set of notes on GitHub.
+---
+
+# Changelog
+
+OpenSCvx follows [semantic versioning](https://semver.org/). Every tagged release ships its own
+snapshot of these docs (selectable from the version picker in the header) and a full set of
+release notes on GitHub.
+
+- :material-tag-outline: __[Release notes on GitHub](https://github.com/OpenSCvx/OpenSCvx/releases)__
+  — the authoritative, per-version changelog with highlights, fixes, and upgrade notes.
+- :material-package-variant: __[Releases on PyPI](https://pypi.org/project/openscvx/#history)__
+  — published wheels and source distributions.
+
+The documentation you are reading tracks the `latest` release. Use the version selector to browse
+the docs for an earlier tag, or switch to `nightly` for the in-development build from `main`.

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/citation.md

@@ -1,9 +1,23 @@
+---
+title: Citation
+description: >-
+  How to cite OpenSCvx and the successive-convexification methods it implements,
+  including Hayner et al., IEEE RA-L 2025, in BibTeX.
+---
+
 # Citation
 
-If you use OpenSCvx in your research, please cite the following works:
+If you use OpenSCvx in your research, please cite Hayner et al., *Continuous-Time
+Line-of-Sight Constrained Trajectory Planning for 6-Degree of Freedom Systems*,
+IEEE Robotics and Automation Letters (RA-L), 2025
+([DOI: 10.1109/LRA.2025.3545299](https://doi.org/10.1109/LRA.2025.3545299)),
+along with the methodological and solver references below.
 
 ## Primary Citation
 
+Hayner et al., IEEE RA-L 2025 — DOI:
+[10.1109/LRA.2025.3545299](https://doi.org/10.1109/LRA.2025.3545299).
+
 ```bibtex
 @ARTICLE{hayner2025los,
         author={Hayner, Christopher R. and Carson III, John M. and Açıkmeşe, Behçet and Leung, Karen},
@@ -19,6 +33,10 @@ If you use OpenSCvx in your research, please cite the following works:
 
 ## Methodological Foundation
 
+Elango et al., *Successive Convexification for Trajectory Optimization with
+Continuous-Time Constraint Satisfaction*, 2024 — preprint:
+[arXiv:2404.16826](https://arxiv.org/abs/2404.16826).
+
 ```bibtex
 @misc{elango2024ctscvx,
       title={Successive Convexification for Trajectory Optimization with Continuous-Time Constraint Satisfaction}, 
@@ -33,6 +51,10 @@ If you use OpenSCvx in your research, please cite the following works:
 
 ## Solver Technology
 
+Chari and Açıkmeşe, *QOCO: A Quadratic Objective Conic Optimizer with Custom
+Solver Generation*, 2025 — preprint:
+[arXiv:2503.12658](https://arxiv.org/abs/2503.12658).
+
 ```bibtex
 @misc{chari2025qoco,
   title = {QOCO: A Quadratic Objective Conic Optimizer with Custom Solver Generation},
@@ -44,6 +66,14 @@ If you use OpenSCvx in your research, please cite the following works:
 }
 ```
 
+## Citing the software
+
+To cite the OpenSCvx software itself, use the
+[`CITATION.cff`](https://github.com/OpenSCvx/OpenSCvx/blob/main/CITATION.cff) file
+at the repository root — GitHub's "Cite this repository" widget reads it directly.
+It points to the RA-L paper above as the preferred citation. A dedicated software
+DOI (Zenodo) is planned for the 1.0 release.
+
 ## Acknowledgments
 
 This work was supported by a NASA Space Technology Graduate Research Opportunity and the Office of Naval Research under grant N00014-17-1-2433. The authors would like to acknowledge Natalia Pavlasek, Samuel Buckner, Abhi Kamath, Govind Chari, and Purnanand Elango as well as the other Autonomous Controls Laboratory members, for their many helpful discussions and support throughout this work. 

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/examples.md

@@ -1,3 +1,8 @@
+---
+description: >-
+  Runnable OpenSCvx trajectory optimization examples spanning aerospace, robotics, and abstract optimal-control problems.
+---
+
 # Examples
 
 OpenSCvx comes with a comprehensive set of examples demonstrating various trajectory optimization problems. These examples are located in the `examples/` folder and cover different applications and complexity levels.

{openscvx-0.5.3.dev39 → openscvx-0.5.3.dev40}/docs/index.md

@@ -5,12 +5,24 @@ hide:
   - navigation
   - toc
 description: >-
-  An Open-Source Modular and Extensible Nonlinear Trajectory Optimization Package
+  OpenSCvx is an open-source Python library for nonlinear trajectory
+  optimization built on successive convexification (SCvx), with a composable
+  problem API and a JAX backend.
 social:
   cards_layout_options:
     title: Fast and Easy Nonconvex Trajectory Optimization
 ---
 
+# OpenSCvx — Trajectory Optimization via Successive Convexification in Python/JAX
+
+OpenSCvx is an open-source Python library for nonlinear trajectory optimization
+built on successive convexification (SCvx). You write dynamics, costs, and
+constraints as a single composable problem object; the library lowers that
+symbolic definition to JAX, discretizes it on a time grid, and solves the
+resulting nonconvex problem through a sequence of convex subproblems. The same
+problem definition runs on CPU and GPU, and vectorizes across decision nodes and
+scenario batches.
+
 ## Why OpenSCvx
 
 **Modeling.** Dynamics, costs, and constraints are defined together in a structured problem object.
@@ -30,9 +42,8 @@ for every outer loop (see [Obstacle avoidance with Vmap](UsersGuide/03_obstacle_
 
 <div class="grid cards" markdown>
 
-- :material-rocket-launch: __[Run examples](examples.md)__ — locate scripts in the repo, run them locally, and browse problem categories.
 - :material-book-open-variant: __[Users guide](UsersGuide/00_introduction.md)__ — modeling, constraints, and visualization.
 - :material-code-braces: __[API reference](Reference/index.md)__ — modules and functions generated from source with docstrings.
-- :material-view-dashboard: __[Examples](Examples/index.md)__ — runnable scripts organized by topic.
+- :material-view-dashboard: __[Examples](Examples/index.md)__ — runnable scripts organized by topic, run them locally and browse problem categories.
 
 </div>