Update README to first public version

Author: hayk-skydio

README.md

@@ -1,44 +1,45 @@
 <img alt="SymForce" src="https://symforce-6d87c842-22de-4727-863b-e556dcc9093b.vercel.app/images/symforce_horizontal_white.png" width="600px"/>
 
-[![Documentation](https://img.shields.io/badge/api-docs-blue)](https://symforce-6d87c842-22de-4727-863b-e556dcc9093b.vercel.app/docs/index.html)
+[![Documentation](https://img.shields.io/badge/api-docs-blue)](https://symforce.org)
 [![Source Code](https://img.shields.io/badge/source-code-blue)](https://github.com/symforce-org/symforce)
 [![Issues](https://img.shields.io/badge/issue-tracker-blue)](https://github.com/symforce-org/symforce/issues)
 ![Python 3.8](https://img.shields.io/badge/python-3.8-blue)
 ![C++ 14](https://img.shields.io/badge/c++-14-blue)
 
 ---
-<span style="color:red"><b>WARNING: SymForce is strictly confidential until its public release.</b></span>
 
-SymForce is a Python and C++ library for symbolic computation and code generation. It contains three independently useful systems:
+SymForce is a fast symbolic computation and code generation library for robotics applications like computer vision, state estimation, motion planning, and controls. It combines the development speed and flexibility of symbolic mathematics with the performance of autogenerated, highly optimized code in C++ or any target runtime language. SymForce contains three independently useful systems:
 
-+ **Symbolic Toolkit** - builds on the SymPy API to provide rigorous geometric and camera types, lie group calculus, singularity handling, and tools to model large problems
++ **Symbolic Toolkit** - builds on the SymPy API to provide rigorous geometric and camera types, lie group calculus, singularity handling, and tools to model complex problems
 
 + **Code Generator** - transforms symbolic expressions into blazing-fast, branchless code with clean APIs and minimal dependencies, with a template system to target any language
 
-+ **Optimization Library** - performs on-manifold factor graph optimization with a highly optimized implementation for real-time robotics applications
++ **Optimization Library** - a fast tangent-space optimization library based on factor graphs, with a highly optimized implementation for real-time robotics applications
 
-SymForce accelerates robotics and computer vision tasks like visual odometry, bundle adjustment, calibration, sparse nonlinear MPC, and embedded motor control.
+SymForce automatically computes tangent space Jacobians, eliminating the need for any bug-prone handwritten derivatives. Generated functions can be directly used as factors in our nonlinear optimizer. This workflow enables faster runtime functions, faster development time, and fewer lines of handwritten code versus alternative methods.
+
+SymForce was developed at [Skydio](https://skydio.com/). It is used in production to accelerate tasks like SLAM, bundle adjustment, calibration, and sparse nonlinear MPC for autonomous robots at scale.
 
 <br/>
 
 <img alt="SymForce" src="https://symforce-6d87c842-22de-4727-863b-e556dcc9093b.vercel.app/images/symforce_diagram.png" width="700px"/>
 
 <br/>
 
-Features:
-
-+ Rapidly prototype and analyze complex problems with symbolic math, with a seamless workflow into production use
-+ Compute fast and correct tangent-space jacobians for any expression
-+ Reduce duplication and minimize bugs by generating native runtime code in multiple languages from a canonical symbolic representation
-+ Generate embedded-friendly C++ functions that depend only on Eigen, are templated on the scalar type, and require no dynamic allocation
-+ Outperform automatic differentiation techniques, sometimes by 10x
-+ Leverage high quality, battle-hardened, and performant APIs at all levels
+#### Features:
 
-# Note to early access participants
+ + Symbolic implementations of geometry and camera types with Lie group operations
+ + Code generation of fast native runtime code from symbolic expressions, reducing duplication and minimizing bugs
+ + Novel tools to compute fast and correct tangent-space jacobians for any expression, avoiding all handwritten derivatives
+ + Strategies for flattening computation and leveraging sparsity that can yield 10x speedups over standard autodiff
+ + A fast tangent-space optimization library in C++ and Python based on factor graphs
+ + Rapid prototyping and analysis of complex problems with symbolic math, with a seamless workflow into production use
+ + Embedded-friendly C++ generation of templated Eigen code with zero dynamic memory allocation
+ + Highly performant, modular, tested, and extensible code
 
-Thank you for helping us develop SymForce! We value the time you're taking to provide feedback during this private beta program.
+# Early Access Notes
 
-You will be invited to a private Slack channel with the authors. Please file specific issues on Github, and then use Slack for discussion. Do not share any links or code without express permission from the authors.
+Thank you for helping us develop SymForce! We value the time you're taking to provide feedback during this private beta program. We expect some rough edges and slow, missing, or confusing aspects of the library. Please file [issues](https://github.com/symforce-org/symforce/issues) on GitHub and we will work to address them.
 
 Things to try:
 
@@ -52,16 +53,10 @@ Things to try:
 * Use the C++ Factor and Optimizer to solve a problem
 * Read and understand the SymForce codebase
 
-[**Read the docs!**](https://symforce-6d87c842-22de-4727-863b-e556dcc9093b.vercel.app/docs/index.html)
-
-We know that currently some things will be slow, missing, or confusing. We're working on it, but please let us know what you encounter.
-
-In the future we will share a survey with specific questions, but more generally we are interested in all feedback you can provide about the value of the library, comparisons to alternatives, and any guidance to us.
+[**Read the docs!**](https://symforce.org)
 
 # Build from source
 
-<span style="color:blue">TODO: Create wheels for <code style="color:blue"><b>pip install symforce</b></code></span>
-
 SymForce requires Python 3.8 or later. We suggest using conda or virtualenv:
 
 ```
@@ -114,6 +109,8 @@ Verify the installation in Python:
 >>> geo.Rot3()
 ```
 
+<span style="color:blue">TODO: Create wheels for <code style="color:blue"><b>pip install symforce</b></code></span>
+
 # Tutorial
 
 Let's walk through a simple example of modeling and solving an optimization problem with SymForce. In this example a robot moves through a 2D plane and the goal is to estimate its pose at multiple time steps given noisy measurements.
@@ -233,7 +230,7 @@ def odometry_residual(
     return geo.V1((pose_b.t - pose_a.t).norm(epsilon=epsilon) - dist)
 ```
 
-Now we can create [`Factor`](https://symforce-6d87c842-22de-4727-863b-e556dcc9093b.vercel.app/docs/api/symforce.opt.factor.html) objects from the residual functions and a set of keys. The keys are named strings for the function arguments, which will be accessed by name from a [`Values`](https://symforce-6d87c842-22de-4727-863b-e556dcc9093b.vercel.app/docs/api/symforce.values.values.html) class we later instantiate with numerical quantities.
+Now we can create [`Factor`](https://symforce.org/api/symforce.opt.factor.html?highlight=factor#module-symforce.opt.factor) objects from the residual functions and a set of keys. The keys are named strings for the function arguments, which will be accessed by name from a [`Values`](https://symforce.org/api/symforce.values.values.html) class we later instantiate with numerical quantities.
 
 ```python
 from symforce.opt.factor import Factor
@@ -267,7 +264,7 @@ Here is a visualization of the structure of this factor graph:
 
 Our goal is to find poses of the robot that minimize the residual of this factor graph, assuming the
 landmark positions in the world are known. We create an
-[`Optimizer`](https://symforce-6d87c842-22de-4727-863b-e556dcc9093b.vercel.app/docs/api/symforce.opt.optimizer.html)
+[`Optimizer`](https://symforce.org/api/symforce.opt.optimizer.html?highlight=optimizer#module-symforce.opt.optimizer)
 with these factors and tell it to only optimize the pose keys (the rest are held constant):
 ```python
 from symforce.opt.optimizer import Optimizer
@@ -280,7 +277,7 @@ optimizer = Optimizer(
 )
 ```
 
-Now we need to instantiate numerical [`Values`](https://symforce-6d87c842-22de-4727-863b-e556dcc9093b.vercel.app/docs/api/symforce.values.values.html) for the problem, including an initial guess for our unknown poses (just set them to identity).
+Now we need to instantiate numerical [`Values`](https://symforce.org/api/symforce.values.values.html?highlight=values#module-symforce.values.values) for the problem, including an initial guess for our unknown poses (just set them to identity).
 
 ```python
 import numpy as np
@@ -295,7 +292,7 @@ initial_values = Values(
 )
 ```
 
-Now run the optimization! This returns an [`Optimizer.Result`](https://symforce-6d87c842-22de-4727-863b-e556dcc9093b.vercel.app/docs/api/symforce.opt.optimizer.html#symforce.opt.optimizer.Optimizer.Result) object that contains the optimized values, error statistics, and per-iteration debug stats (if enabled).
+Now run the optimization! This returns an [`Optimizer.Result`](https://symforce.org/api/symforce.opt.optimizer.html?highlight=optimizer#symforce.opt.optimizer.Optimizer.Result) object that contains the optimized values, error statistics, and per-iteration debug stats (if enabled).
 ```python
 result = optimizer.optimize(initial_values)
 ```
@@ -315,24 +312,24 @@ All of the code for this example can also be found in `symforce/examples/robot_2
 
 SymForce provides `sym` packages with runtime code for geometry and camera types that are generated from its symbolic `geo` and `cam` packages. As such, there are multiple versions of a class like `Pose3` and it can be a common source of confusion.
 
-The canonical symbolic class [`geo.Pose3`](https://symforce-6d87c842-22de-4727-863b-e556dcc9093b.vercel.app/docs/api/symforce.geo.pose3.html) lives in the `symforce` package:
+The canonical symbolic class [`geo.Pose3`](https://symforce.org/api/symforce.geo.pose3.html) lives in the `symforce` package:
 ```python
 from symforce import geo
 geo.Pose3.identity()
 ```
 
-The autogenerated Python runtime class [`sym.Pose3`](https://symforce-6d87c842-22de-4727-863b-e556dcc9093b.vercel.app/docs/api-gen-py/sym.pose3.html) lives in the `sym` package:
+The autogenerated Python runtime class [`sym.Pose3`](https://symforce.org/api-gen-py/sym.pose3.html?highlight=pose3#module-sym.pose3) lives in the `sym` package:
 ```python
 import sym
 sym.Pose3.identity()
 ```
 
-The autogenerated C++ runtime class [`sym::Pose3`](https://symforce-6d87c842-22de-4727-863b-e556dcc9093b.vercel.app/docs/api-gen-cpp/class/classsym_1_1Pose3.html) lives in the `sym::` namespace:
+The autogenerated C++ runtime class [`sym::Pose3`](https://symforce.org/api-gen-cpp/class/classsym_1_1Pose3.html) lives in the `sym::` namespace:
 ```C++
 sym::Pose3<double>::Identity()
 ```
 
-The matrix type for symbolic code is [`geo.Matrix`](https://symforce-6d87c842-22de-4727-863b-e556dcc9093b.vercel.app/docs/api/symforce.geo.matrix.html), for generated Python is [`numpy.ndarray`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html), and for C++ is [`Eigen::Matrix`](https://eigen.tuxfamily.org/dox/group__TutorialMatrixClass.html).
+The matrix type for symbolic code is [`geo.Matrix`](https://symforce.org/api/symforce.geo.matrix.html?highlight=matrix#module-symforce.geo.matrix), for generated Python is [`numpy.ndarray`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html), and for C++ is [`Eigen::Matrix`](https://eigen.tuxfamily.org/dox/group__TutorialMatrixClass.html).
 
 The symbolic classes can also handle numerical values, but will be dramatically slower than the generated classes. The symbolic classes must be used when defining functions for codegen and optimization. Generated functions always accept the runtime types.
 
@@ -344,7 +341,7 @@ As a convenience, the Python `Optimizer` class can accept symbolic types in its
 
 Let's look under the hood to understand how that optimization worked. For each factor, SymForce introspects the form of the symbolic function, passes through symbolic inputs to build an output expression, automatically computes tangent-space jacobians of those output expressions wrt the optimized variables, and generates fast runtime code for them.
 
-The [`Codegen`](https://symforce-6d87c842-22de-4727-863b-e556dcc9093b.vercel.app/docs/api/symforce.codegen.codegen.html) class is the central tool for generating runtime code from symbolic expressions. In this case, we pass it the bearing residual function and configure it to generate C++ code:
+The [`Codegen`](https://symforce.org/api/symforce.codegen.codegen.html?highlight=codegen#module-symforce.codegen.codegen) class is the central tool for generating runtime code from symbolic expressions. In this case, we pass it the bearing residual function and configure it to generate C++ code:
 ```python
 from symforce.codegen import Codegen, CppConfig
 
@@ -540,17 +537,25 @@ $ -->
 
 # Learn More
 
-You can find more SymForce tutorials [here](https://symforce-6d87c842-22de-4727-863b-e556dcc9093b.vercel.app/docs/index.html#guides).
+You can find more SymForce tutorials [here](https://symforce.org/#guides).
 
 # License
 
-SymForce is released under the [BSD-3](https://opensource.org/licenses/BSD-3-Clause) license.
+SymForce is released under the [Apache 2.0](https://spdx.org/licenses/Apache-2.0.html) license.
 
 See the LICENSE file for more information.
 
+# Sponsors
+
+SymForce is developed and maintained by [Skydio](https://skydio.com/). It is released as a free and open-source library for the robotics community. Contributors to the project are welcome!
+
+<a href="http://skydio.com">
+<img alt="Skydio Logo" src="https://logovectordl.com/wp-content/uploads/2021/03/skydio-inc-logo-vector.png" width="300px" />
+</a>
+
 # Future Ideas
 
-There are lots of features we'd like to add, or would be happy to see added by contributors from the
+There are several features we'd like to add, or would be happy to see added by contributors from the
 community.  Some of these are outlined in
 [the current Issues](https://github.com/symforce-org/symforce/issues), but some other major possible
 additions are:
@@ -559,10 +564,3 @@ additions are:
 functions, such as trig functions
 - Add more backend languages, such as CUDA, GLSL/HLSL, and TypeScript
 - More Lie group types, in particular Sim(3)
-
-<style>
-img.latex-eqn {
-    background-color:white;
-    padding: 20px;
-}
-</style>