Our Product Vision & Roadmap
KittyCAD is providing the first API for hardware designers. Prior to now, we had not made public the vision for our product. Starting with this blog post, we will be regularly updating our vision for the future and what we are working on.
To begin, I would like to share the vision for what we're developing:
- Hardware design infrastructure for the internet: Millions of companies of all sizes—from startups to Fortune 500s—use antiquated software to design, manufacture, and manage their hardware projects. The majority of this is done offline.
- The backbone for any hardware business: For ambitious companies around the world, KittyCAD makes hardware as simple, borderless, and programmable as the rest of the internet.
- Unified platform - A fully integrated suite of hardware design products: We bring together everything that’s required to design, manufacture, and manage hardware projects: Workflow Automation, a CAD Engine, and Application Frameworks.
- Developed for designers - The world’s most powerful and easy-to-use APIs: We develop the right software so our customers don’t need to stitch together disparate systems or spend months manually completing repetitive tasks.
We've turned this vision into a three phase development roadmap, which we summarize at a high level below, and then break that down into specific features.
We have split our product development into three phases. The majority of the development is being done sequentially, with elements of all three phases happening in parallel. A detailed breakdown of each phase is further below.
- Phase 1: Workflow Automation Automation and scripting of the hardware design ecosystem. These are low barrier-to-entry features both for development, and for adoption. Examples being file management, revision control, metadata access and use, integration into other software tools like CI/CD workflows and git.
- Phase 2: CAD Engine Addition of geometric creation and edits, expanding on the market entry with workflow automation. Allows the scripting not only of the operations before/after CAD edits, but also inclusive of CAD edits.
- Phase 3: Application Frameworks Developing products that combine the workflow automation and CAD engine in a tighter feedback loop, such as auto-generation of CAD geometries based on requirements, automatically pushing a completed & verified design to manufacturing, multi-physics analysis of a part and edits of the base geometry to improve performance, etc..
Automation and scripting of the hardware design ecosystem. These are low barrier-to-entry features both for development, and for adoption. Examples being file management, revision control, metadata access and use, integration into other software tools like CI/CD workflows and git.
|Github Actions||Integrate with Github Actions so customers can interact with low barrier-to-entry workflow automation features quickly on Github, without hosting their own infrastructure.|
|File Format Conversions||Provide an API for file format conversion to customers bypassing traditional, GUI-based conversions that are often constrained or require additional licenses in order to run. Additionally, this develops the required infrastructure to allow conversion of files from current file formats to the soon-to-be KittyCAD file format.|
|Metadata: Body Properties||Provide an API for generating calculated properties of the bodies within CAD files, such as mass, volume, center of gravity, moment of inertia, material properties data, and more. Currently, these values are generated manually within current CAD GUIs.|
|Metadata: Surface & Edge Properties||Provide an API for generating calculated properties of the surfaces and edges of CAD bodies. Similar to body properties, these properties are not accessible outside of a CAD GUI. This API provides programmatic access to the features of each surface, such as area, or the boundary curves of the surface. For edges, features like the profile of the edge, length, etc...|
|Metadata: CAD Feature Properties||Provide an API for generating the properties of CAD features. These would be the parameters input to the underlying CAD commands that generate the geometry, such as length of an extrusion, elements of a CAD sketch, number of elements of a pattern. These are input commands, not output geometry like the body, surface, and edge features.|
|Metadata: Manufacturing Properties||Provide an API for adding manufacturing data to bodies, surfaces, and edges. For example, adding a manufacturing tolerance to a surface, which would be later referenced in an engineering drawing. Currently, these values are calculated in spreadsheets, by hand, or similar locations without connectivity into the CAD environment. This data can be added both as static values, and as their own classes/equations which can be re-calculated based on outside values changing.|
|Metadata: Supply Chain Properties||Provide an API for adding supply chain data to CAD files. Currently, this data is added manually into enterprise systems not digitally connected to the CAD environment. For example, enabling the CAD file to include metadata about the material property constraints of raw material needed for a part, or the specification of heat treatment that must happen after a part goes through a machining step.|
|Rendering Engine||Provide an API for generating high-quality renderings of CAD files. Often these are manually generated within CAD environments with significant manual setup by the engineer, and impossible to set up the same twice. These renderings are used for downstream manufacturing, design reviews, product documentation, marketing materials, and more.|
|File Formats: KittyCAD Format||Create a new file format standard that natively incorporates the metadata capability described above. This file format introduced the CAD geometry as the "source of truth", accessible as a software object. This structures the data where it can be queried, manually modified, programmatically modified, and re-calculated. This file format uses the developments of the modern graphics and gaming industries, allowing high-resolution representation of engineered geometries meant for processing with GPU technology, without the excessive file size often generated through the decades old file formats used in today's industry.|
|Constant Material Properties||Within the KittyCAD file format, representation of material properties that do not vary across the volume of the body. While some current CAD file formats can define the material by name, they do not include properties such as stress/strain curves and other specific material properties that the part was designed to. Simply a material name such as "structural steel" is insufficient to define which alloy, specification, temper, etc... the part was actually engineered to and this information is documented in an alternative or additional enterprise system.|
|Variable Material Properties||There is currently no file format in the world that can handle material properties that vary across a single body within CAD. This happens in numerous real world applications, such as welds creating heat effected zones that affect local material properties, or 3D printing applications that have variable heat input across a part or can print continuously with a variable set of deposition properties. This creates major challenges because of the limitations of file formats, where analyzing the performance of these parts is not directly possible. Instead, engineers attempt to create discrete representations of these properties, such as dividing a CAD file into two parts. However this similarly creates major challenges in engineering analysis, where the step change in properties is not realistic, and creates challenges for the meshing and solver technologies within multiphysics packages. We would provide a location-specific property set within our CAD files that could be manually or programmatically defined, and referenced on a location-by-location basis programmatically including by multiphysics simulation software.|
|CAD File Digital Security||Building on top of the KittyCAD proprietary file format, providing a revokable permission structure, such as through API-keys and/or certificates that allow access to all or specific elements of a CAD file to other users, team members, outside contractors, vendors, etc... There is no current alternative for this today other than password protected zip files which do not provide the ability to revoke permissions, not provide permanent security once they are un-zipped.|
|Analysis Platform Integrations||Provide integrations to multiphysics analysis platforms, such as the ANSYS API, that allow tighter CAD-to-multiphysics integrations that are overly difficult or impossible today without programmatic access to CAD metadata.|
|Engineering Drawing API||Provide an API for generating engineering drawings off of CAD files and their metadata, currently defined and updated manually be engineers within a CAD environment.|
|KittyCAD Litterbox||Create a web-hostable environment supporting simultaneously a coding environment in addition to a CAD object visualizer in order to foster the education and onboarding pipeline for current and potential customers.|
|Examples/Tutorials/Use Cases||Examples/Tutorials/Use Cases for usability, customer conversion, lowering barrier to entry, communication, encouraging people to build platforms on top of KittyCAD infrastructure, not just one off scripts or scripts for their own / their company's use.|
|Flatland -> 3D||Migrate the community from flatland (2D native) to 3D native thinking and workflows through education and examples. The traditional mechanical engineering workflows are trained to think of 2D primitives, such as an engineer used to have on a sketchpad or drafting table, combined to created 3D shapes. With computers, 3D primitives are possible, but are not part of engineering CAD packages today.|
|Visualizer / Developer Environment||Visualizer extensions alongside code used as a development environment, where a developer can simultaneously write code and see the the impact of their code modifying or accessing features within a CAD file.|
|Debug Environment||Furthering the visualizing developer environment, create a lint debug toolkit to be included within the development. environment.|
|Team Accounts||Team billing allows team managers/execs or companies that don't have individual engineer level billing authority to use our product in a cohesive way. There may be other team collaboration/sharing/etc... features that can branch out from this. We can have payments and calls from a parent account through child accounts so teams can monitor which individuals are using what resources, invite users, SSO, etc..|
|Enterprise Accounts||As an extension to team accounts, enterprise accounts would include a dedicated support member/team, and features supporting large enterprise integration.|
|GovCloud Offering||This will be a constraint for many companies that are currently on self-hosted infrastructure and sensitive to U.S. government cloud regulations.|
|Debugging, logging, API performance metrics/monitoring||This is a general solution to the question of us knowing how well our solutions are operating in the field and responding to real-time to issues that come up or bottlenecks that creep on us. Us not delivering a high-performing solution, and staying ahead of growth could be massively impactful to customer confidence over time.|
|KittyCAD development pipeline||Includes improvements, compartmentalization of infrastructure development vs. kernel development, systems feature development. Guarantee we continue to have efficiency as the team grows, as technical product gets more complex. Graphics pipeline split as is currently developed is a step in the right direction here.|
|Sessions||Need a way to 'open a session' and 'close a session' so that the one-off calls can turn into a series of calls. As parts get more complicated, network performance can become a bottleneck and not transferring them back/forth every call will be beneficial.|
|Caching||Caching of user files for reducing repetitive computation needs.|
Addition of geometric creation and edits, expanding on the market entry with workflow automation. Allows the scripting not only of the operations before/after CAD edits, but also inclusive of CAD edits.
|CAD Engine||There are countless features that make up a CAD engine, starting with primitives of various complexity, turning those primitives into more advanced shapes, and various levels of manipulation of those primitives and shapes. This CAD engine would be cloud-based, able to adopt the most advanced developments in GPU compute and acceleration, and be entirely accessible through our REST API|
|GPU acceleration, GPU compute||Introduce GPU acceleration and compute to the processing of our CAD engine.|
Developing products that combine the workflow automation and CAD engine in a tighter feedback loop, such as auto-generation of CAD geometries based on requirements, automatically pushing a completed & verified design to manufacturing, multi-physics analysis of a part and edits of the base geometry to improve performance, etc..
|Design Loop Iteration||Provide an API based framework for connecting our workflow automation and CAD engine, such that designs can be iterated upon, downstream automation built to evaluate the performance and satisfaction of requirements of the design, and changes made to the original design that go through the loop again.|
|Unit Tests / Requirements Verification||Provide an API based framework to simplify the development of downstream propagation of verified designs. For example, once a design is completed that satisfies requirements and tests performed on it, our CI/CD offering would ease the ability to push that completed design automatically into a machine shop, factory floor, or another manufacturing/downstream location without minimal or zero human intervention.|
|CNC Toolpath Automation||Create an API based framework for generating CNC toolpaths off of KittyCAD geometries. With the greater digital access to features, tolerances, properties possible with the KittyCAD API, better automation of toolpaths can be generated off of our files than any other files.|
|CNC Machinability||Create an API based framework that determines if a specific design can be manufactured within a specific CNC machine. This is an extremely monotonous and laborious part of machine shop operations.|
|Machine Shop Quoting||Create an API that allows quoting of machine shop jobs, built on top of the above APIs. Once machine time, type, tooling required based on specific features/materials/tolerances/etc..., the API can provide quotes for manufacturing cost. This is done right now manually through sales representatives and significant back-and-forth iteration both internal to the machine shop and with the customer.|
|Machine Shop Operating System||Combining together the above APIs, create an offering for machine shops to not only manage their internal operations, but also provide an endpoint available to their current/potential customers that can be pinged to quote and submit jobs automatically without human intervention. These endpoints can be the target of customer design scripts, allowing a completed design at the customer to request quotes, and submit to the most applicable machine shop without human intervention.|
|Design Dashboards||Dashboards for systems engineers, product leadership, company leadership, etc... for monitoring design metrics, product performance, design progress, etc... built on top of a variety of other KittyCAD API features.|
|Requirement Frameworks||Provide an API based requirements framework that allows simplified translation of systems requirements, specifications, coupled performance parameters between parts and systems - all in a dynamic manner that can respond to changes, and deliver those changes to designs that are both in-work and completed, to initiate design updates and confirm satisfactory changes.|
|Integration with GPT-3 or similar||Integrate KittyCAD's API with GPT-3 or similar such that KittyCAD CAD engine commands can be auto-generated based on the desired geometry, performance, design constraints etc... and remove the human from manually defining every surface and feature.|
|Integration with multiphysics learning||Integrate the KittyCAD API through machine learning to engineering analysis result, including the inverse of those results. Analysis results can be predicted without replicating the full multiphysics solving process, or in the inverse case, performance can be input and geometry be predicted.|
|Auto-design Software||Create an API based framework to allow machine-learning based iteration of a design, such that the iteration to converge on requirements is driven by machine learning of previous and current iteration results, instead of a more traditional iteration loop convergence.|
|Reverse generation of CAD files||Many CAD file formats are not history based, which means that they only output the resulting geometry, not the sequence of CAD commands that were used to create that geometry. Without history, design intent is lost, and makes modification of these files difficult if not impossible. The KittyCAD API and associated intelligence can predict what underlying commands led to the result geometry, and can present high probability options to the end user to choose between.|
|Digital Twin||Live testing of how a new design would behave in a real-world environment. Digital twins are highly beneficial, but very difficult to integrate given the ties between real-world situations, design parameters, manufacturing variance, etc... These challenges are eased through KittyCAD API frameworks for tying these areas together programmatically.|
|Hardware-In-The-Loop / Software-In-The-Loop Models||Create an API framework for developing Hardware-In-The-Loop / Software-In-The-Loop models. These are common in highly regulated industries such as aviation, where corner cases that can not easily be demonstrated during test flights need to be verified. By using digital twin technology that can be rapidly developed and deployed, the barrier to entry and development effort to developing these solutions is highly reduced.|
|Generalized Manufacturing Workflows||In addition to the features for "computer aided manufacturing" which often refers specifically to programming of CNC machines for subtractive manufacturing / machining services, generalizes those features to be usable by a spectrum of manufacturing processes.|
|CAD GUI Toolkit||There will always be a market for CAD GUIs, and that market is almost impenetrable given the technical barrier-to-entry required in developing a CAD engine behind the GUI. For developers and companies interested in developing their own CAD GUIs, perhaps to compete with the mainstream CAD GUI market, we would create a framework that allows simplified integration of our CAD engine underneath CAD GUIs developed by any developer, in their language and platform of choice, for either specific or generalized markets.|
|PLM, ERP, MES, MRP Toolkits||Product Lifecycle Management, Enterprise Resource Planning, Manufacturing Execution Systems, and Manufacturing Resource Planning, are all outdated enterprise software systems that create extreme burdens for hardware companies. While the KittyCAD API can replace all functionality of these enterprise products, there is a cohort of customers that is still extremely attached to these kinds of products. By providing toolkits to developers providing alternatives to current incumbents in those industries, we allow a new generation of developers to build modern solutions on top of KittyCAD infrastructure catered towards these entrenched enterprises.|