{"id":4198,"date":"2026-04-21T06:34:15","date_gmt":"2026-04-21T10:34:15","guid":{"rendered":"https:\/\/blogs.mathworks.com\/matlab\/?p=4198"},"modified":"2026-04-21T06:34:15","modified_gmt":"2026-04-21T10:34:15","slug":"matlab-r2026a-has-been-released-whats-new","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/matlab\/2026\/04\/21\/matlab-r2026a-has-been-released-whats-new\/","title":{"rendered":"MATLAB R2026a has been released – What’s new?"},"content":{"rendered":"
Every MATLAB release has an enormous number of new features across over a hundred different toolboxes and blocksets; far too many to discuss in a single blog post. So, I don't even try! What I do is take a dive into the <\/span>full release notes<\/span><\/a> and pick out what is of personal interest to me.<\/span><\/div>
Some of my picks are major new products such as Simulink Copilot or MATLAB Course Designer. Others are individual functions, workflows or even updates to individual functions that I'm interested in. Some are big, others are small. This is my tour of What's new in MATLAB R2026a. I hope you enjoy it and I hope you'll tell me what your highlights are from this release.<\/span><\/div>

Automatic Differentiation Support for ODEs<\/span><\/h2>
Automatic Differentiation<\/span><\/a> is a good idea. So good in fact that MATLAB has three different implementations of it (long story!). You'll find it in <\/span>Deep Learning Toolbox<\/span><\/a>, <\/span>Optimization Toolbox<\/span><\/a> and now, base MATLAB in the particular case of solving systems of Ordinary Differential Equations. <\/span><\/div>
In R2026a you can use the<\/span> <\/span>JacobianMethod<\/span> <\/span>property of an<\/span> <\/span>ode<\/span><\/a> <\/span>object to specify whether the solver calculates the Jacobians for a given problem using finite differences or automatic differentiation. By default, the Jacobians are calculated using finite differences. By setting <\/span>JacobianMethod=\"autodiff\"<\/span> you'll switch to using Automatic Differentiation which might be faster for large stiff systems and more accurate for sensitivity analyses. For more details see <\/span>https:\/\/www.mathworks.com\/help\/matlab\/math\/ode-autodiff-background.html<\/span><\/a><\/div>
This is the latest in a multi-release series of updates for ODEs and the first in a new series of updates for Automatic Differentiation. <\/span><\/div>

Function metadata and Introspection<\/span><\/h2>
The new <\/span>metafunction<\/span><\/a> object allows you to programmatically get information about function signatures and arguments. Here's a quick example. Save this function to your path as <\/span>greet.m<\/span><\/div>
function msg = greet(name, greeting)<\/span><\/span><\/div>
% greet Create a greeting message<\/span><\/span><\/div>
 <\/div>
arguments (Input)<\/span><\/span><\/div>
name (1,1) string<\/span><\/span><\/div>
greeting (1,1) string = \"Hello\"<\/span><\/span><\/div>
end<\/span><\/span><\/div>
 <\/div>
msg = greeting + \", \" + name + \"!\";<\/span><\/span><\/div>
end<\/span><\/span><\/div><\/div>
Here's an example of it in use<\/span><\/div>
greet(<\/span>\"Mike\"<\/span>,<\/span>\"Subscribe to the MATLAB Blog\"<\/span>)<\/span><\/span><\/div>
ans = <\/span>\"Subscribe to the MATLAB Blog, Mike!\"<\/div><\/div><\/div><\/div><\/div><\/div>
Applying <\/span>metafunction<\/span> to this gives<\/span><\/div>
mf = metafunction(<\/span>\"greet\"<\/span>)<\/span><\/span><\/div>
mf = <\/span><\/div>
Function with properties:\r\n\r\n Name: 'greet'\r\n Description: 'Create a greeting message'\r\n DetailedDescription: 'This is an example that Mike made up for his blog post'\r\n FullPath: 'C:\\Users\\walki\\MATLAB Drive\\blog26\\MATLAB26a\\greet.m'\r\n NamespaceName: ''\r\n Signature: [1\u00d71 matlab.metadata.CallSignature]\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
Drilling down further, we can find the <\/span>CallSignature<\/span><\/a> of our function and can see that it has 2 inputs, 1 output and that input validation is in use. <\/span><\/div>
mf.Signature<\/span><\/span><\/div>
ans = <\/span><\/div>
CallSignature with properties:\r\n\r\n Inputs: [1\u00d72 matlab.metadata.Argument]\r\n Outputs: [1\u00d71 matlab.metadata.Argument]\r\n HasInputValidation: 1\r\n HasOutputValidation: 0\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
Taking a look at the second Input, I can see that it has a default value<\/span><\/div>
mf.Signature.Inputs(2)<\/span><\/span><\/div>
ans = <\/span><\/div>
Argument with properties:\r\n\r\n Identifier: greeting\r\n Description: ''\r\n DetailedDescription: ''\r\n Required: 0\r\n Repeating: 0\r\n NameValue: 0\r\n Validation: [1\u00d71 matlab.metadata.ArgumentValidation]\r\n DefaultValue: [1\u00d71 matlab.metadata.DefaultArgumentValue]\r\n SourceClass: [0\u00d70 matlab.metadata.Class]\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
Let's see what that default value is<\/span><\/div>
mf.Signature.Inputs(2).DefaultValue<\/span><\/span><\/div>
ans = <\/span><\/div>
DefaultArgumentValue with properties:\r\n\r\n Expression: '\"Hello\"'\r\n ReferencedArguments: [1\u00d70 ArgumentIdentifier]\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
This is just scratching the surface of what you can do with this new functionality. Head over to <\/span>Function Instrospection and Metadata<\/span><\/a> in the documentation to learn more.<\/span><\/div>

Simulink Copilot<\/span><\/h2>
MATLAB Copilot was released in R2025a and with over 1 million users at the time of writing, it has proven to be rather popular. This year it is joined by <\/span>Simulink Copilot<\/span><\/a> which brings generative AI-powers to Model-Based Design.<\/span><\/div>
\"\"<\/img><\/a><\/div>

Managing Python environments in MATLAB<\/span><\/h2>
MATLAB's Python integration gets better with every release and the big news in R2026a is that you can now manage and create Python environments directly from MATLAB. This is done via the new External Languages panel. When I opened it, this is what I saw on my machine<\/span><\/div>
\"\"<\/img><\/div>
I right clicked on the base environment shown above and saw all of the Python packages that I have installed in that environment.<\/span><\/div>
\"\"<\/img><\/div>
My versions of Numba and Numpy were not as up to date as I'd like so I selected them and clicked Update. As easy as that! The system supports Virtual Environments, installing a suite of packages from a <\/span>requirements.txt<\/span> file and more. Full details in the documentation at <\/span>Manage Python Environments Using External Languages Panel<\/span><\/a>.<\/span><\/div>
The latest version of Python supported by MATLAB R2026a is now 3.13 and versions back to 3.9 are also supported in this release.<\/span><\/div>

Additional automatic conversions between MATLAB and Python datatypes<\/span><\/h3>
MATLAB has had direct support for various Python types for several years now and this continues to be expanded over time. I <\/span>discussed the use of numerical NumPy arrays in MATLAB<\/span><\/a> back in December 2024 when this had already been available for several releases. Converting between Pandas DataFrames and MATLAB tables was added in R2024a and R2026a adds the automatic conversion between MATLAB string arrays and Python lists. Let's bring all of this together into a code example.<\/span><\/div>
In Python, we can create a DataFrame from a NumPy array and a Python list like this<\/span><\/div>
import pandas as pd<\/span><\/span><\/div>
import numpy as np<\/span><\/span><\/div>
 <\/div>
arr = np.random.rand(10, 4)<\/span><\/span><\/div>
colnames = ['A', 'B', 'C', 'D']<\/span><\/span><\/div>
df = pd.DataFrame(arr, columns=colnames)<\/span><\/span><\/div><\/div>
Using the MATLAB interface to Python, we have been able to do this from within MATLAB for some time<\/span><\/div>
arr = py.numpy.random.rand(int32(10),int32(4));<\/span><\/span><\/div><\/div>
colnames = py.list([<\/span>'A'<\/span>,<\/span>'B'<\/span>,<\/span>'C'<\/span>,<\/span>'D'<\/span>]);<\/span><\/span><\/div><\/div>
 <\/div><\/div>
df = py.pandas.DataFrame(arr, columns=colnames);<\/span><\/span><\/div><\/div><\/div>
However, thanks to the cumulative support for automatic conversion between MATLAB and Python datatypes, we can now create a Pandas DataFrame from a MATLAB numerical array and a MATLAB string array.<\/span><\/div>
% This works in R2026a because [\"A\",\"B\",\"C\",\"D\"] is auto-converted to a<\/span><\/span><\/div><\/div>
% Python list<\/span><\/span><\/div><\/div>
df = py.pandas.DataFrame(rand(10,4),columns=[<\/span>\"A\"<\/span>,<\/span>\"B\"<\/span>,<\/span>\"C\"<\/span>,<\/span>\"D\"<\/span>])<\/span><\/span><\/div>
df = <\/span><\/div>
Python DataFrame with properties:\r\n\r\n T: [1\u00d71 py.pandas.core.frame.DataFrame]\r\n at: [1\u00d71 py.pandas.core.indexing._AtIndexer]\r\n attrs: [1\u00d71 py.dict]\r\n axes: [1\u00d72 py.list]\r\n columns: [1\u00d71 py.pandas.core.indexes.base.Index]\r\n dtypes: [1\u00d71 py.pandas.core.series.Series]\r\n empty: 0\r\n flags: [1\u00d71 py.pandas.core.flags.Flags]\r\n iat: [1\u00d71 py.pandas.core.indexing._iAtIndexer]\r\n iloc: [1\u00d71 py.pandas.core.indexing._iLocIndexer]\r\n index: [1\u00d71 py.pandas.core.indexes.range.RangeIndex]\r\n loc: [1\u00d71 py.pandas.core.indexing._LocIndexer]\r\n ndim: [1\u00d71 py.int]\r\n shape: [1\u00d72 py.tuple]\r\n size: [1\u00d71 py.int]\r\n style: [1\u00d71 py.pandas.io.formats.style.Styler]\r\n values: [1\u00d71 py.numpy.ndarray]\r\n\r\n A B C D\r\n 0 0.032601 0.644765 0.251806 0.906308\r\n 1 0.561200 0.376272 0.290441 0.879654\r\n 2 0.881867 0.190924 0.617091 0.817761\r\n 3 0.669175 0.428253 0.265281 0.260728\r\n 4 0.190433 0.482022 0.824376 0.594356\r\n 5 0.368917 0.120612 0.982663 0.022513\r\n 6 0.460726 0.589507 0.730249 0.425259\r\n 7 0.981638 0.226188 0.343877 0.312719\r\n 8 0.156405 0.384619 0.584069 0.161485\r\n 9 0.855523 0.582986 0.107769 0.178766\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
I can use this DataFrame in whatever Python functions can consume it and when I am done I can convert the result to a MATLAB table.<\/span><\/div>
myTable = table(df)<\/span><\/span><\/div>
<\/div>
<\/div>
<\/div>
<\/div>
myTable = <\/span>10\u00d74 table <\/span><\/div>
<\/span><\/th>A<\/span><\/th>B<\/span><\/th>C<\/span><\/th>D<\/span><\/th><\/tr><\/thead>
1<\/span><\/th>0.0326<\/span><\/td>0.6448<\/span><\/td>0.2518<\/span><\/td>0.9063<\/span><\/td><\/tr>
2<\/span><\/th>0.5612<\/span><\/td>0.3763<\/span><\/td>0.2904<\/span><\/td>0.8797<\/span><\/td><\/tr>
3<\/span><\/th>0.8819<\/span><\/td>0.1909<\/span><\/td>0.6171<\/span><\/td>0.8178<\/span><\/td><\/tr>
4<\/span><\/th>0.6692<\/span><\/td>0.4283<\/span><\/td>0.2653<\/span><\/td>0.2607<\/span><\/td><\/tr>
5<\/span><\/th>0.1904<\/span><\/td>0.4820<\/span><\/td>0.8244<\/span><\/td>0.5944<\/span><\/td><\/tr>
6<\/span><\/th>0.3689<\/span><\/td>0.1206<\/span><\/td>0.9827<\/span><\/td>0.0225<\/span><\/td><\/tr>
7<\/span><\/th>0.4607<\/span><\/td>0.5895<\/span><\/td>0.7302<\/span><\/td>0.4253<\/span><\/td><\/tr>
8<\/span><\/th>0.9816<\/span><\/td>0.2262<\/span><\/td>0.3439<\/span><\/td>0.3127<\/span><\/td><\/tr>
9<\/span><\/th>0.1564<\/span><\/td>0.3846<\/span><\/td>0.5841<\/span><\/td>0.1615<\/span><\/td><\/tr>
10<\/span><\/th>0.8555<\/span><\/td>0.5830<\/span><\/td>0.1078<\/span><\/td>0.1788<\/span><\/td><\/tr><\/tbody><\/table><\/div><\/div><\/div><\/div><\/div><\/div>
I hope that this gives some flavor of how seamless the integration between MATLAB and Python is becoming. Another new addition in R2026a is the <\/span>pystringarray<\/span><\/a> function that converts MATLAB string arrays to <\/span>NumPyStringDtype<\/span> arrays<\/span><\/div>
mla = [<\/span>\"Subscribe\" \"To\" <\/span>missing; <\/span>\"The\" \"MATLAB\" \"Blog\"<\/span>]<\/span><\/span><\/div>
<\/div>
<\/div>
<\/div>
<\/div>
mla = <\/span>2\u00d73 string<\/span><\/div><\/div>
\"Subscribe\" \"To\" <missing>
\"The\" \"MATLAB\" \"Blog\"
<\/div>
<\/mw-icon><\/div>
<\/mw-icon><\/div><\/div><\/div><\/div><\/div><\/div>
npa = pystringarray(mla)<\/span><\/span><\/div>
npa = <\/span><\/div>
Python ndarray:\r\n\r\n [['Subscribe' 'To' None]\r\n ['The' 'MATLAB' 'Blog']]\r\n\r\n Use details function to view the properties of the Python object.\r\n\r\n Use string function to convert to a MATLAB array.\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
For more details on how to pass MATLAB Data to Python along with everything that's supported see the documentation: <\/span>Pass Data Between MATLAB and Python from MATLAB - MATLAB & Simulink<\/span><\/a><\/div>

OpenJDK Java Support<\/span><\/h2>
While on the subject of language interoperability, I now turn my attention to Java. Currently, MATLAB installations on Windows and Linux platforms include Oracle Java.<\/span> However, in a future release, MATLAB will no longer include Oracle Java as part of its installation<\/span><\/a>. Instead, you will have to download and install the MATLAB Support for OpenJDK add-on or any compatible OpenJDK.<\/span><\/div>
You can do this from directly within MATLAB from the <\/span>Add-On Explorer<\/span><\/a><\/div>
\"\"<\/img><\/div>
Alternatively, you can download and install any compatible OpenJDK distribution from<\/span> <\/span>https:\/\/adoptium.net\/<\/span><\/a>. For information about supported versions, see<\/span> <\/span>Versions of OpenJDK Compatible with MATLAB by Release<\/span><\/a>. The <\/span>jenv<\/span><\/a> command has also been updated to support the use of OpenJDK. <\/span><\/div>

MATLAB Coder Support Package for PyTorch and LiteRT Models<\/span><\/h2>
MATLAB Coder has been one of my secret weapons for years, allowing me to deterministically generate high performance and portable C\/C++ code directly from MATLAB code. If you've never used it before, work through the <\/span>MATLAB Coder Onramp<\/span><\/a>: it will be half an hour well-spent. <\/span><\/div>
The new<\/span> <\/span>MATLAB Coder Support Package for PyTorch and LiteRT Models<\/span><\/a> is an add-on for MATLAB Coder that allows you to <\/span>generate C\/C++ code directly from PyTorch and LiteRT models<\/span>. You can also generate CUDA code from these models via this add on and <\/span>GPU Coder<\/span><\/a>.<\/span><\/div>
The best way to understand what this can do for you is to work through some examples and I have three for you, all new in R2026a<\/span><\/div>