Autodesk Developer Blog

Innovate. Integrate. Automate

Revit 2027 SDK: .NET 10, API Changes and Additions

—

by

Pedro Nadal
in

Following the evolution of the Revit platform over recent releases, Revit 2027 represents a significant step forward in both platform modernization and API design.

This release continues a broader effort to simplify APIs, improve extensibility, and better align Revit with modern development practices.

The Revit 2027 SDK is now available and can be downloaded from the APS portal: https://aps.autodesk.com/developer/overview/revit

Note: for a complete list of API changes and additions, please refer to the SDK documentation.

API changes

A platform transition to .NET 10

Revit 2027 now runs on .NET 10. This is the first and most important change for developers.

With this update, developers are now fully aligned with the latest .NET runtime. This brings performance improvements, better tooling support, and long-term platform consistency across the ecosystem.

All add-ins must be built against the .NET 10 SDK. In most cases, this means updating your build configuration and ensuring your development environment is aligned with the new runtime.

A typical global.json update looks like:


{
  "sdk": {
    "version": "10.0.100",
    "rollForward": "minor"
  }
}

For many developers, this will be the first step when migrating:

  • Update SDK and tooling to .NET 10
  • Review compatibility changes from .NET 8/9
  • Rebuild and validate add-ins

There are some minor breaking changes since .NET 8, see:

Add-in isolation and dependency management

A major improvement in Revit 2027 is the introduction of enhanced add-in isolation.

Developers can now explicitly define how add-ins depend on each other and how assemblies are shared. This is exposed through new types such as:

  • AddInDependencyBase
  • ClientIdDependency
  • ContextNameDependency

And new manifest settings:

  • PublicAssemblies
  • Dependencies
  • UseAllContextsForDependencyResolution

This gives developers much better control over assembly resolution and helps avoid conflicts in larger plugin ecosystems.

A sample manifest (refer to SDK for a complete sample):


<?xml version="1.0" encoding="utf-8"?>
<revitaddins>
    <addin type="Application">
        <assembly><path to="" your="" addin="" installation="" directory="">\Plugin.dll</path></assembly>
        <clientid>00000000-0000-0000-0000-000000000000</clientid>
        <fullclassname>Plugin.App</fullclassname>
        <name>Test Plugin</name>
    </addin>
    <manifestsettings>
        <userevitcontext>False</userevitcontext>
        <contextname>MyPluginContextName</contextname>
        <useallcontextsfordependencyresolution>True</useallcontextsfordependencyresolution>
        <publicassemblies>
            <assembly>..\MyAddInFolder\Plugin.API.dll</assembly>
            <assembly>D:\MyAddInFolder\Plugin.Service.API.dll</assembly>
        </publicassemblies>
        <dependencies>
            <dependsonclientid clientid="11111111-1111-1111-1111-111111111111">
                <assemblyname>Plugin2.API.dll</assemblyname>
                <assemblyname>Plugin2.Service.API.dll</assemblyname>
            </dependsonclientid>
            <dependsoncontext contextname="Default">
                <assemblyname>SomeDLL.API.dll</assemblyname>
            </dependsoncontext>
        </dependencies>
    </manifestsettings>
</revitaddins>

Add-in installation folder changes

Revit 2027 also introduces an important deployment-related update: the location used for all-user add-ins has changed.

For improved security, Revit no longer looks for machine-wide add-ins under ProgramData. Instead, the all-user locations now move under Program Files.

Previous locations:

C:\ProgramData\Autodesk\Revit\Addins\20XX
C:\ProgramData\Autodesk\ApplicationPlugins

New locations:

C:\Program Files\Autodesk\Revit\Addins\20XX
C:\Program Files\Autodesk\ApplicationPlugins

Per-user add-in locations are still supported, but this change affects how Revit discovers add-ins installed for all users. It also changes the value returned by Application.AllUsersAddinsLocation

Cloud Model API changes

With the expansion of Autodesk cloud regions, Revit 2027 introduces a more flexible way to work with cloud models.

Instead of hardcoded regions:

  • CloudRegionUS
  • CloudRegionEMEA

developers now use:

  • ModelPathUtils.GetAllCloudRegions()

API Additions

Extended properties and external data

One of the more interesting directions in Revit 2027 is the introduction of Extended Properties and a broader push toward external data integration.

Traditionally, Revit parameters have been the primary way to store and access data. That model works well for data authored inside Revit, but becomes limiting when integrating information coming from external systems.

Extended properties introduce a more flexible approach.

At a high level, they allow you to:

  • Attach data that originates outside Revit
  • Store and manage that data within the document
  • Access it through a unified parameter-like API

The entry point for this is the ParameterAccess API, along with several new classes in the Autodesk.Revit.ExternalData namespace such as:

  • ExtendedPropertiesLink
  • ExtendedParameterElement
  • ExtendedPropertiesBindings

These act as a bridge between Revit and external data sources.

A simplified conceptual flow looks like this:


// Link external data source
var link = new ExtendedPropertiesLink(...);

// Define a property
var paramElement = new ExtendedParameterElement(...);

// Bind it to categories or instances
var bindings = new ExtendedPropertiesBindings(...);

External Data Manager framework

Closely related to extended properties is the new External Data Manager framework, which brings external data into the Revit UI.

Specifically, it allows developers to integrate custom data types into the Manage Links dialog.

The core interface is:


public class MyServer : IExternalDataManagerServer
{
    public IList GetData()
    {
        // Return rows displayed in Manage Links
    }

    public void OnCommand(...)
    {
        // Handle actions like Add, Reload, Remove
    }
}

Each row in the dialog is represented by an ExternalDataManagerDataItem, which contains properties such as:

  • Name
  • Status
  • Path
  • Version
  • Size

Commands are defined separately using ExternalDataManagerCommand and then exposed through the server.

This framework effectively opens up the Manage Links dialog to custom data types.

You can now:

  • Register your own external data sources
  • Provide custom commands like load, reload, or custom actions
  • Display structured data alongside Revit links

In practice, this means you can build:

  • Connectors to external platforms
  • Data-driven workflows integrated directly into Revit’s UI

Numbering API overhaul

The numbering system has been redesigned and generalized.

It is no longer limited to a small set of categories. Developers can now define numbering schemas for any elements in the model.

This enables flexible workflows based on filters, parameters, and geometry. It represents a shift from sequence-based numbering to rule-based numbering.

Material API and embodied carbon

New APIs introduce embodied carbon data into the Revit material system.

A simple workflow:


var asset = new EmbodiedCarbonAsset(...);

var element = PropertySetElement.Create(doc, asset);

material.EmbodiedCarbonAssetId = element.Id;

This supports sustainability workflows and environmental analysis directly within the model.

Annotation and tagging improvements

Annotation APIs have been extended to provide more control over tag leaders.


Reference taggedReference = tag.GetTaggedReferences().FirstOrDefault();

tag.LeaderStartCondition = LeaderStartCondition.Free;

XYZ currentStart = tag.GetLeaderStart(taggedReference);
XYZ newStart = currentStart + new XYZ(DefaultOffsetFeet, 0.0, 0.0);
tag.SetLeaderStart(taggedReference, newStart);

This allows more precise control over annotation layout and improves documentation workflows.

Deprecated and removed APIs

As part of the ongoing cleanup effort, several APIs have been deprecated or removed.

Examples include:

  • AXM import functionality (FormIt)
  • Mechanical.Zone members
  • Legacy rebar creation methods
  • Several EnergyDataSettings properties

Developers should review these changes carefully when upgrading existing add-ins.

Notes on building the SDK samples

As with most major platform transitions, updating the SDK also means that some sample projects may require a few adjustments before they build cleanly in every environment.

If you encounter compilation or build errors when opening the Revit 2027 SDK samples, the following fixes may help.

Fixing CA1416 errors

Some projects may report CA1416 platform compatibility warnings or errors. A practical solution is to add the Windows platform attribute once at solution level and include it across the SDK samples.

Create a shared file:

VSProps\GlobalPlatformAssemblyInfo.cs

using System.Runtime.Versioning;

[assembly: SupportedOSPlatform("windows")]

Then include it from SDKSamples.props:


<ItemGroup>
  <Compile Include="$(SolutionDir)VSProps\GlobalPlatformAssemblyInfo.cs" />
</ItemGroup>

This provides a simple centralized fix and avoids touching each sample individually.

Fixing WFO1000

If you encounter WFO1000, it can be suppressed for the entire solution.

Add the following to both SDKSamples.props and SDKSamples.VB.props:


<PropertyGroup>
  <NoWarn>$(NoWarn);WFO1000</NoWarn>
</PropertyGroup>

This keeps the sample solution building cleanly while preserving the original project structure.

Fixing missing references

A few sample projects may fail because references to Advance Steel, Steel Connections add-ins, or the Macros API are not resolved automatically.

In these cases, using explicit HintPath references is a reliable fix.

For CivilAlignments.csproj:


<ItemGroup>
  <Reference Include="Autodesk.CivilAlignments.DBApplication">
    <HintPath>..\..\..\..\Program Files\Autodesk\Revit 2027\AddIns\CivilAlignments\Autodesk.CivilAlignments.DBApplication.dll</HintPath>
  </Reference>
</ItemGroup>

For SampleCommandsSteelElements.csproj:


<ItemGroup>
  <Reference Include="ASObjectsMgd">
    <HintPath>..\..\..\..\Program Files\Autodesk\Revit 2027\Addins\SteelConnections\ASObjectsMgd.dll</HintPath>
    <Private>False</Private>
  </Reference>
  <Reference Include="ASGeometryMgd">
    <HintPath>..\..\..\..\Program Files\Autodesk\Revit 2027\Addins\SteelConnections\ASGeometryMgd.dll</HintPath>
    <Private>False</Private>
  </Reference>
  <Reference Include="ASCADLinkMgd">
    <HintPath>..\..\..\..\Program Files\Autodesk\Revit 2027\Addins\SteelConnections\ASCADLinkMgd.dll</HintPath>
    <Private>False</Private>
  </Reference>
  <Reference Include="SteelConnectionsDB">
    <HintPath>..\..\..\..\Program Files\Autodesk\Revit 2027\Addins\SteelConnections\Autodesk.SteelConnectionsDB.dll</HintPath>
    <Private>False</Private>
  </Reference>
</ItemGroup>

For NewMacro.csproj:


<ItemGroup>
  <Reference Include="RevitAPIMacros">
    <HintPath>..\..\..\..\Program Files\Autodesk\Revit 2027\RevitAPIMacros.dll</HintPath>
  </Reference>
  <Reference Include="RevitAPIUIMacros">
    <HintPath>..\..\..\..\Program Files\Autodesk\Revit 2027\RevitAPIUIMacros.dll</HintPath>
  </Reference>
</ItemGroup>

These changes make the dependencies explicit and avoid machine-specific resolution issues.

Fixing the post-build error in ScheduleToHTML

Another issue that may appear when building the samples is a post-build failure in ScheduleToHTML.csproj.

The root cause is that xcopy may prompt interactively if the destination path is ambiguous. In a build process, that results in a failure.

A more reliable approach is to ensure the destination folder exists, use a trailing slash, and pass /i so the copy runs non-interactively.

Updated PostBuildEvent:


<PostBuildEvent>
  set FILEFORSAMPLEREG="$(SolutionDir)..\..\..\..\Regression\API\SDKSamples\UpdateSampleDllForRegression.py"
  if exist %FILEFORSAMPLEREG% py -3 %FILEFORSAMPLEREG% "$(ProjectPath)" "$(TargetPath)" "$(SolutionDir)"
  if not exist "$(SolutionDir)..\..\..\..\Regression\API\SDKSamples\ScheduleToHTML\CS\" mkdir "$(SolutionDir)..\..\..\..\Regression\API\SDKSamples\ScheduleToHTML\CS\"
  xcopy /f /y /i "$(Pkghtmltextwriter)\lib\netstandard2.0\*.*" "$(SolutionDir)..\..\..\..\Regression\API\SDKSamples\ScheduleToHTML\CS\"
</PostBuildEvent>

This avoids the interactive prompt and makes the post-build step deterministic.

Final thoughts

Revit 2027 reflects a clear direction for the platform.

There is a strong focus on modernization, simplification, and extensibility. The move to .NET 10, improved dependency management, and new data integration capabilities all point toward a more scalable and flexible ecosystem.

For developers, this release requires some migration effort, but it also unlocks new possibilities for building more robust and integrated solutions.

Comments

Leave a Reply

Discover more from Autodesk Developer Blog

Subscribe now to keep reading and get access to the full archive.

Continue reading