diff --git a/PinataTests/CMakeLists.txt b/PinataTests/CMakeLists.txt
index b73f54e..60eff6c 100644
--- a/PinataTests/CMakeLists.txt
+++ b/PinataTests/CMakeLists.txt
@@ -1,13 +1,31 @@
 cmake_minimum_required(VERSION 3.16)
-project(PinataTests C CXX)
+
+if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.27)
+    cmake_policy(SET CMP0144 NEW)
+    if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.30)
+        cmake_policy(SET CMP0167 NEW)
+    endif()
+endif()
+
+project(PinataTests VERSION 4.0 LANGUAGES C CXX)
 
 find_package(OpenSSL REQUIRED)
 find_package(GTest REQUIRED)
 find_package(Boost REQUIRED)
 
-set(DILITHIUM PQClean/crypto_sign/dilithium3/clean)
-set(KYBER PQClean/crypto_kem/kyber512/clean)
-set(COMMON PQClean/common)
+include(FetchContent)
+FetchContent_Declare(
+    pqm4
+    GIT_REPOSITORY https://github.com/mupq/pqm4.git
+    # Keep this git hash the same as the one in src/CMakeLists.txt !
+    GIT_TAG a24bb4b662016968c19f5e6a0719c9ad530f0286
+)
+FetchContent_MakeAvailable(pqm4)
+
+# We can reuse the PQClean sources checked out by PQM4.
+set(DILITHIUM "${pqm4_SOURCE_DIR}/mupq/pqclean/crypto_sign/ml-dsa-65/clean")
+set(KYBER "${pqm4_SOURCE_DIR}/mupq/pqclean/crypto_kem/ml-kem-512/clean")
+set(COMMON "${pqm4_SOURCE_DIR}/mupq/pqclean/common")
 
 add_executable(PinataTests
     main.cpp
@@ -39,5 +57,7 @@ add_executable(PinataTests
 )
 
 target_compile_features(PinataTests PRIVATE cxx_std_20)
-target_include_directories(PinataTests PRIVATE PQClean/common)
+target_include_directories(PinataTests PRIVATE "${pqm4_SOURCE_DIR}/mupq/pqclean/common")
+set_source_files_properties(PqcFirmware.cpp PROPERTIES INCLUDE_DIRECTORIES "${pqm4_SOURCE_DIR}/mupq/pqclean")
 target_link_libraries(PinataTests PRIVATE Boost::boost OpenSSL::Crypto GTest::GTest)
+
diff --git a/PinataTests/PqcFirmware.cpp b/PinataTests/PqcFirmware.cpp
index 85fd533..9626e9e 100644
--- a/PinataTests/PqcFirmware.cpp
+++ b/PinataTests/PqcFirmware.cpp
@@ -4,76 +4,73 @@
 #include <openssl/rand.h>
 
 extern "C" {
-#include "PQClean/crypto_kem/kyber512/clean/api.h"
-#include "PQClean/crypto_sign/dilithium3/clean/api.h"
+#include "crypto_kem/ml-kem-512/clean/api.h"
+#include "crypto_sign/ml-dsa-65/clean/api.h"
 }
 
-#define DILITHIUM_PUBLIC_KEY_SIZE 1952
-#define DILITHIUM_PRIVATE_KEY_SIZE 4016
-#define DILITHIUM_SIGNATURE_SIZE 3293
-#define DILITHIUM_MESSAGE_SIZE 16
-#define DILITHIUM_SIGNED_MESSAGE_SIZE (DILITHIUM_SIGNATURE_SIZE + DILITHIUM_MESSAGE_SIZE)
+#define MLDSA_PUBLIC_KEY_SIZE 1952
+#define MLDSA_PRIVATE_KEY_SIZE 4032
+#define MLDSA_SIGNATURE_SIZE 3309
+#define MLDSA_MESSAGE_SIZE 16
+#define MLDSA_N 256
+#define MLDSA_SIGNED_MESSAGE_SIZE (MLDSA_SIGNATURE_SIZE + MLDSA_MESSAGE_SIZE)
 
-#define KYBER512_PUBLIC_KEY_SIZE 800
-#define KYBER512_PRIVATE_KEY_SIZE 1632
-#define KYBER512_SHARED_SECRET_SIZE 32
-#define KYBER512_CIPHERTEXT_SIZE 768
+#define MLKEM_PUBLIC_KEY_SIZE 800
+#define MLKEM_PRIVATE_KEY_SIZE 1632
+#define MLKEM_SHARED_SECRET_SIZE 32
+#define MLKEM_CIPHERTEXT_SIZE 768
 
-#if DILITHIUM_PUBLIC_KEY_SIZE != PQCLEAN_DILITHIUM3_CLEAN_CRYPTO_PUBLICKEYBYTES
+#if MLDSA_PUBLIC_KEY_SIZE != PQCLEAN_MLDSA65_CLEAN_CRYPTO_PUBLICKEYBYTES
 #error invalid public key size, update me!
 #endif
-#if DILITHIUM_PRIVATE_KEY_SIZE != PQCLEAN_DILITHIUM3_CLEAN_CRYPTO_SECRETKEYBYTES
+#if MLDSA_PRIVATE_KEY_SIZE != PQCLEAN_MLDSA65_CLEAN_CRYPTO_SECRETKEYBYTES
 #error invalid private key size, update me!
 #endif
-#if DILITHIUM_SIGNATURE_SIZE != PQCLEAN_DILITHIUM3_CLEAN_CRYPTO_BYTES
+#if MLDSA_SIGNATURE_SIZE != PQCLEAN_MLDSA65_CLEAN_CRYPTO_BYTES
 #error invalid signature size, update me!
 #endif
 
-#if defined(MODE) && !defined(DILITHIUM_MODE)
-#define DILITHIUM_MODE MODE
-#endif
-
-#if KYBER512_PUBLIC_KEY_SIZE != PQCLEAN_KYBER512_CLEAN_CRYPTO_PUBLICKEYBYTES
+#if MLKEM_PUBLIC_KEY_SIZE != PQCLEAN_MLKEM512_CLEAN_CRYPTO_PUBLICKEYBYTES
 #error invalid public key size, update me!
 #endif
-#if KYBER512_PRIVATE_KEY_SIZE != PQCLEAN_KYBER512_CLEAN_CRYPTO_SECRETKEYBYTES
+#if MLKEM_PRIVATE_KEY_SIZE != PQCLEAN_MLKEM512_CLEAN_CRYPTO_SECRETKEYBYTES
 #error invalid secret key size, update me!
 #endif
-#if KYBER512_SHARED_SECRET_SIZE != PQCLEAN_KYBER512_CLEAN_CRYPTO_BYTES
+#if MLKEM_SHARED_SECRET_SIZE != PQCLEAN_MLKEM512_CLEAN_CRYPTO_BYTES
 #error invalid secret size, update me!
 #endif
 
 class PqcFirmware : public TestBase {
     void SetUp() override {
-        if (Environment::getInstance().getFirmwareVariant() != FirmwareVariant::PostQuantum) {
-            GTEST_SKIP();
-        }
+//        if (Environment::getInstance().getFirmwareVariant() != FirmwareVariant::PostQuantum) {
+//            GTEST_SKIP();
+//        }
     }
 };
 
 TEST_F(PqcFirmware, DilithiumLevel3) {
-    std::array<unsigned char, DILITHIUM_PUBLIC_KEY_SIZE> publicKey;
-    std::array<unsigned char, DILITHIUM_PRIVATE_KEY_SIZE> privateKey;
-    std::array<unsigned char, DILITHIUM_MESSAGE_SIZE> message;
-    std::array<unsigned char, PQCLEAN_DILITHIUM3_CLEAN_CRYPTO_BYTES + DILITHIUM_MESSAGE_SIZE> pinataSignedMessage;
-    std::array<unsigned char, PQCLEAN_DILITHIUM3_CLEAN_CRYPTO_BYTES + DILITHIUM_MESSAGE_SIZE> referenceSignedMessage;
+/*    std::array<unsigned char, MLDSA_PUBLIC_KEY_SIZE> publicKey;
+    std::array<unsigned char, MLDSA_PRIVATE_KEY_SIZE> privateKey;
+    std::array<unsigned char, MLDSA_MESSAGE_SIZE> message;
+    std::array<unsigned char, PQCLEAN_MLDSA65_CLEAN_CRYPTO_BYTES + MLDSA_MESSAGE_SIZE> pinataSignedMessage;
+    std::array<unsigned char, PQCLEAN_MLDSA65_CLEAN_CRYPTO_BYTES + MLDSA_MESSAGE_SIZE> referenceSignedMessage;
 
     // Ensure the mode is the same
     std::cerr << "asserting security level\n";
-    ASSERT_EQ(mClient.dilithiumGetSecurityLevel(), 3);
+    ASSERT_EQ(mClient.mldsaGetSecurityLevel(), 3);
 
     // Ensure public and private key sizes match
     std::cerr << "checking key sizes\n";
-    const auto [pinataPublicKeySize, pinataPrivateKeySize] = mClient.dilithiumGetKeySizes();
-    ASSERT_EQ(pinataPublicKeySize, PQCLEAN_DILITHIUM3_CLEAN_CRYPTO_PUBLICKEYBYTES);
-    ASSERT_EQ(pinataPrivateKeySize, PQCLEAN_DILITHIUM3_CLEAN_CRYPTO_SECRETKEYBYTES);
+    const auto [pinataPublicKeySize, pinataPrivateKeySize] = mClient.mldsaGetKeySizes();
+    ASSERT_EQ(pinataPublicKeySize, PQCLEAN_MLDSA65_CLEAN_CRYPTO_PUBLICKEYBYTES);
+    ASSERT_EQ(pinataPrivateKeySize, PQCLEAN_MLDSA65_CLEAN_CRYPTO_SECRETKEYBYTES);
 
     // Generate a public/private key pair with the reference X86 implementation
-    PQCLEAN_DILITHIUM3_CLEAN_crypto_sign_keypair(publicKey.data(), privateKey.data());
+    PQCLEAN_MLDSA65_CLEAN_crypto_sign_keypair(publicKey.data(), privateKey.data());
 
     // Tell the pinata to use this public/private key pair for signing with Dilithium3
     std::cerr << "setup public/private key pair\n";
-    mClient.dilithiumSetPublicPrivateKeyPair(publicKey.data(), publicKey.size(), privateKey.data(), privateKey.size());
+    mClient.mldsaSetPublicPrivateKeyPair(publicKey.data(), publicKey.size(), privateKey.data(), privateKey.size());
 
     // Prepare the random message
     std::fill(pinataSignedMessage.begin(), pinataSignedMessage.end(), (unsigned char)0);
@@ -81,58 +78,58 @@ TEST_F(PqcFirmware, DilithiumLevel3) {
 
     // Sign the fuzzed message on pinata
     std::cerr << "sign message\n";
-    mClient.dilithiumSign(message.data(), message.size(), pinataSignedMessage.data(),
-                          PQCLEAN_DILITHIUM3_CLEAN_CRYPTO_BYTES);
+    mClient.mldsaSign(message.data(), message.size(), pinataSignedMessage.data(),
+                          PQCLEAN_MLDSA65_CLEAN_CRYPTO_BYTES);
 
     // Concatenate the signature and the fuzzed message together to obtain a "signed message"
-    ASSERT_EQ(pinataSignedMessage.size(), PQCLEAN_DILITHIUM3_CLEAN_CRYPTO_BYTES + message.size());
-    std::copy(message.begin(), message.end(), pinataSignedMessage.data() + PQCLEAN_DILITHIUM3_CLEAN_CRYPTO_BYTES);
+    ASSERT_EQ(pinataSignedMessage.size(), PQCLEAN_MLDSA65_CLEAN_CRYPTO_BYTES + message.size());
+    std::copy(message.begin(), message.end(), pinataSignedMessage.data() + PQCLEAN_MLDSA65_CLEAN_CRYPTO_BYTES);
 
     // The message should be at the end of the signed message buffer
-    ASSERT_EQ(std::memcmp(pinataSignedMessage.data() + PQCLEAN_DILITHIUM3_CLEAN_CRYPTO_BYTES, message.begin(), 16), 0);
+    ASSERT_EQ(std::memcmp(pinataSignedMessage.data() + PQCLEAN_MLDSA65_CLEAN_CRYPTO_BYTES, message.begin(), 16), 0);
 
     // Sign the fuzzed message with the X86 reference implementation.
     // The reference implementation doesn't use randomized signatures.
     unsigned long messageLength = static_cast<unsigned long>(pinataSignedMessage.size());
-    PQCLEAN_DILITHIUM3_CLEAN_crypto_sign(referenceSignedMessage.data(), &messageLength, message.data(), message.size(),
+    PQCLEAN_MLDSA65_CLEAN_crypto_sign(referenceSignedMessage.data(), &messageLength, message.data(), message.size(),
                                          privateKey.data());
     ASSERT_EQ(messageLength, referenceSignedMessage.size());
 
     // Pinata sign --> Reference verify
-    ASSERT_EQ(PQCLEAN_DILITHIUM3_CLEAN_crypto_sign_open(pinataSignedMessage.data(), &messageLength,
+    ASSERT_EQ(PQCLEAN_MLDSA65_CLEAN_crypto_sign_open(pinataSignedMessage.data(), &messageLength,
                                                         pinataSignedMessage.data(), pinataSignedMessage.size(),
                                                         publicKey.data()),
               0);
 
     // Reference sign --> Pinata verify
     std::cerr << "verify message\n";
-    ASSERT_TRUE(mClient.dilithiumVerify(referenceSignedMessage.data(), referenceSignedMessage.size()));
-}
+    ASSERT_TRUE(mClient.mldsaVerify(referenceSignedMessage.data(), referenceSignedMessage.size()));
+*/}
 
 TEST_F(PqcFirmware, Kyber512) {
-    std::array<unsigned char, KYBER512_PUBLIC_KEY_SIZE> publicKey;
-    std::array<unsigned char, KYBER512_PRIVATE_KEY_SIZE> privateKey;
-    std::array<unsigned char, PQCLEAN_KYBER512_CLEAN_CRYPTO_BYTES> ssPinata;
-    std::array<unsigned char, PQCLEAN_KYBER512_CLEAN_CRYPTO_BYTES> ssRef;
-    std::array<unsigned char, PQCLEAN_KYBER512_CLEAN_CRYPTO_BYTES> ssPinataGenerateRefDecode;
-    std::array<unsigned char, PQCLEAN_KYBER512_CLEAN_CRYPTO_BYTES> ssRefGeneratePinataDecode;
-    std::array<unsigned char, PQCLEAN_KYBER512_CLEAN_CRYPTO_BYTES> ssRefGenerateRefDecode;
-    std::array<unsigned char, PQCLEAN_KYBER512_CLEAN_CRYPTO_BYTES> ssPinataGeneratePinataDecode;
-    std::array<unsigned char, PQCLEAN_KYBER512_CLEAN_CRYPTO_CIPHERTEXTBYTES> ctPinata;
-    std::array<unsigned char, PQCLEAN_KYBER512_CLEAN_CRYPTO_CIPHERTEXTBYTES> ctRef;
+    std::array<unsigned char, MLKEM_PUBLIC_KEY_SIZE> publicKey;
+    std::array<unsigned char, MLKEM_PRIVATE_KEY_SIZE> privateKey;
+    std::array<unsigned char, PQCLEAN_MLKEM512_CLEAN_CRYPTO_BYTES> ssPinata;
+    std::array<unsigned char, PQCLEAN_MLKEM512_CLEAN_CRYPTO_BYTES> ssRef;
+    std::array<unsigned char, PQCLEAN_MLKEM512_CLEAN_CRYPTO_BYTES> ssPinataGenerateRefDecode;
+    std::array<unsigned char, PQCLEAN_MLKEM512_CLEAN_CRYPTO_BYTES> ssRefGeneratePinataDecode;
+    std::array<unsigned char, PQCLEAN_MLKEM512_CLEAN_CRYPTO_BYTES> ssRefGenerateRefDecode;
+    std::array<unsigned char, PQCLEAN_MLKEM512_CLEAN_CRYPTO_BYTES> ssPinataGeneratePinataDecode;
+    std::array<unsigned char, PQCLEAN_MLKEM512_CLEAN_CRYPTO_CIPHERTEXTBYTES> ctPinata;
+    std::array<unsigned char, PQCLEAN_MLKEM512_CLEAN_CRYPTO_CIPHERTEXTBYTES> ctRef;
 
     // Ensure public and private key sizes match
     std::cerr << "checking wether key sizes agree\n";
-    const auto [pinataPublicKeySize, pinataPrivateKeySize] = mClient.kyber512GetKeySizes();
-    ASSERT_EQ(pinataPublicKeySize, PQCLEAN_KYBER512_CLEAN_CRYPTO_PUBLICKEYBYTES);
-    ASSERT_EQ(pinataPrivateKeySize, PQCLEAN_KYBER512_CLEAN_CRYPTO_SECRETKEYBYTES);
+    const auto [pinataPublicKeySize, pinataPrivateKeySize] = mClient.mlkemGetKeySizes();
+    ASSERT_EQ(pinataPublicKeySize, PQCLEAN_MLKEM512_CLEAN_CRYPTO_PUBLICKEYBYTES);
+    ASSERT_EQ(pinataPrivateKeySize, PQCLEAN_MLKEM512_CLEAN_CRYPTO_SECRETKEYBYTES);
 
     // Generate a public/private key pair with the reference X86 implementation
-    PQCLEAN_KYBER512_CLEAN_crypto_kem_keypair(publicKey.data(), privateKey.data());
+    PQCLEAN_MLKEM512_CLEAN_crypto_kem_keypair(publicKey.data(), privateKey.data());
 
-    // Tell the pinata to use this public/private key pair for encrypting shared secrets with kyber512.
+    // Tell the pinata to use this public/private key pair for encrypting shared secrets with mlkem.
     std::cerr << "setting public private key pair\n";
-    mClient.kyber512SetPublicPrivateKeyPair(publicKey.data(), publicKey.size(), privateKey.data(), privateKey.size());
+    mClient.mlkemSetPublicPrivateKeyPair(publicKey.data(), publicKey.size(), privateKey.data(), privateKey.size());
 
     // Zero out arrays
     std::fill(ssPinataGenerateRefDecode.begin(), ssPinataGenerateRefDecode.end(), (unsigned char)0);
@@ -142,25 +139,25 @@ TEST_F(PqcFirmware, Kyber512) {
 
     // Generate a shared secret on Pinata
     std::cerr << "generating shared secret\n";
-    mClient.kyber512Generate(ssPinata.data(), ssPinata.size(), ctPinata.data(), ctPinata.size());
+    mClient.mlkemGenerate(ssPinata.data(), ssPinata.size(), ctPinata.data(), ctPinata.size());
 
     // Generate a shared secret with the reference implementation.
-    PQCLEAN_KYBER512_CLEAN_crypto_kem_enc(ctRef.data(), ssRef.data(), publicKey.data());
+    PQCLEAN_MLKEM512_CLEAN_crypto_kem_enc(ctRef.data(), ssRef.data(), publicKey.data());
 
     // Decode the Pinata ciphertext with ref impl
-    PQCLEAN_KYBER512_CLEAN_crypto_kem_dec(ssPinataGenerateRefDecode.data(), ctPinata.data(), privateKey.data());
+    PQCLEAN_MLKEM512_CLEAN_crypto_kem_dec(ssPinataGenerateRefDecode.data(), ctPinata.data(), privateKey.data());
 
     // Decode the ref ciphertext with ref impl
-    PQCLEAN_KYBER512_CLEAN_crypto_kem_dec(ssRefGenerateRefDecode.data(), ctRef.data(), privateKey.data());
+    PQCLEAN_MLKEM512_CLEAN_crypto_kem_dec(ssRefGenerateRefDecode.data(), ctRef.data(), privateKey.data());
 
     // Decode the Pinata ciphertext with Pinata impl
     std::cerr << "decoding shared secret\n";
-    mClient.kyber512Decode(ctPinata.data(), ctPinata.size(), ssPinataGeneratePinataDecode.data(),
+    mClient.mlkemDecode(ctPinata.data(), ctPinata.size(), ssPinataGeneratePinataDecode.data(),
                            ssPinataGeneratePinataDecode.size());
 
     // Decode the ref ciphertext with Pinata impl
     std::cerr << "decoding shared secret (ref)\n";
-    mClient.kyber512Decode(ctRef.data(), ctRef.size(), ssRefGeneratePinataDecode.data(),
+    mClient.mlkemDecode(ctRef.data(), ctRef.size(), ssRefGeneratePinataDecode.data(),
                            ssRefGeneratePinataDecode.size());
 
     ASSERT_EQ(ssPinata, ssPinataGeneratePinataDecode);
diff --git a/PinataTests/common.cpp b/PinataTests/common.cpp
index 8e1bbd9..2078ddb 100644
--- a/PinataTests/common.cpp
+++ b/PinataTests/common.cpp
@@ -14,22 +14,22 @@
 #include <termios.h>
 #include <unistd.h>
 
-constexpr const size_t PINATA_DILITHIUM_MESSAGE_LENGTH = 16;
-constexpr const size_t PINATA_KYBER512_SHARED_SECRET_LENGTH = 32;
+constexpr const size_t PINATA_MLDSA_MESSAGE_LENGTH = 16;
+constexpr const size_t PINATA_MLKEM_SHARED_SECRET_LENGTH = 32;
 
 const uint8_t CMD_GET_CODE_REV = 0xF1;
 const uint8_t CMD_HWAES128_ENC = 0xCA;
 
-const uint8_t CMD_SW_DILITHIUM_GET_VARIANT = 0x90;
-const uint8_t CMD_SW_DILITHIUM_SET_PUBLIC_AND_PRIVATE_KEY = 0x91;
-const uint8_t CMD_SW_DILITHIUM_VERIFY = 0x92;
-const uint8_t CMD_SW_DILITHIUM_SIGN = 0x93;
-const uint8_t CMD_SW_DILITHIUM_GET_KEY_SIZES = 0x94;
+const uint8_t CMD_SW_MLDSA_GET_VARIANT = 0x90;
+const uint8_t CMD_SW_MLDSA_SET_PUBLIC_AND_PRIVATE_KEY = 0x91;
+const uint8_t CMD_SW_MLDSA_VERIFY = 0x92;
+const uint8_t CMD_SW_MLDSA_SIGN = 0x93;
+const uint8_t CMD_SW_MLDSA_GET_KEY_SIZES = 0x94;
 
-const uint8_t CMD_SW_KYBER512_SET_PUBLIC_AND_PRIVATE_KEY = 0x02;
-const uint8_t CMD_SW_KYBER512_GET_KEY_SIZES = 0x03;
-const uint8_t CMD_SW_KYBER512_GENERATE = 0x04;
-const uint8_t CMD_SW_KYBER512_DEC = 0x05;
+const uint8_t CMD_SW_MLKEM_SET_PUBLIC_AND_PRIVATE_KEY = 0x02;
+const uint8_t CMD_SW_MLKEM_GET_KEY_SIZES = 0x03;
+const uint8_t CMD_SW_MLKEM_GENERATE = 0x04;
+const uint8_t CMD_SW_MLKEM_DEC = 0x05;
 
 const uint8_t CMD_SWDES_ENC = 0x44;
 const uint8_t CMD_SWDES_DEC = 0x45;
@@ -89,11 +89,11 @@ std::pair<int, int> PinataClient::getVersion() {
 
 FirmwareVariant PinataClient::determineFirmwareVariant() {
     // Detect it via this command. It will return "BadCmd\n" when dealing with a classic or hw variant.
-    command(CMD_SW_DILITHIUM_GET_VARIANT);
+    command(CMD_SW_MLDSA_GET_VARIANT);
     uint8_t byte;
     read(&byte, sizeof(byte));
     // If we're dealing with a PQC variant then this should return the number "3".
-    if (byte == 3) {
+    if (byte == 65) {
         return FirmwareVariant::PostQuantum;
     } else if (byte != 'B') {
         throw std::runtime_error("unexpected return value");
@@ -122,21 +122,21 @@ FirmwareVariant PinataClient::determineFirmwareVariant() {
     return FirmwareVariant::Classic;
 }
 
-uint8_t PinataClient::dilithiumGetSecurityLevel() {
-    command(CMD_SW_DILITHIUM_GET_VARIANT);
+uint8_t PinataClient::mldsaGetSecurityLevel() {
+    command(CMD_SW_MLDSA_GET_VARIANT);
     return readNumber<uint8_t>();
 }
 
-std::pair<int, int> PinataClient::dilithiumGetKeySizes() {
-    command(CMD_SW_DILITHIUM_GET_KEY_SIZES);
+std::pair<int, int> PinataClient::mldsaGetKeySizes() {
+    command(CMD_SW_MLDSA_GET_KEY_SIZES);
     const uint16_t publicKeySize = readNumber<uint16_t>();
     const uint16_t privateKeySize = readNumber<uint16_t>();
     return std::make_pair(publicKeySize, privateKeySize);
 }
 
-void PinataClient::dilithiumSetPublicPrivateKeyPair(const uint8_t *publicKey, size_t publicKeySize,
-                                                    const uint8_t *privateKey, size_t privateKeySize) {
-    command(CMD_SW_DILITHIUM_SET_PUBLIC_AND_PRIVATE_KEY);
+void PinataClient::mldsaSetPublicPrivateKeyPair(const uint8_t *publicKey, size_t publicKeySize,
+                                                const uint8_t *privateKey, size_t privateKeySize) {
+    command(CMD_SW_MLDSA_SET_PUBLIC_AND_PRIVATE_KEY);
     write(publicKey, publicKeySize);
     write(privateKey, privateKeySize);
     if (readNumber<uint8_t>() != 0) {
@@ -144,9 +144,9 @@ void PinataClient::dilithiumSetPublicPrivateKeyPair(const uint8_t *publicKey, si
     }
 }
 
-void PinataClient::dilithiumSign(const uint8_t *messageBuffer, size_t messageBufferSize, uint8_t *signedMessageBuffer,
-                                 size_t signedMessageBufferSize) {
-    command(CMD_SW_DILITHIUM_SIGN);
+void PinataClient::mldsaSign(const uint8_t *messageBuffer, size_t messageBufferSize, uint8_t *signedMessageBuffer,
+                             size_t signedMessageBufferSize) {
+    command(CMD_SW_MLDSA_SIGN);
     write(messageBuffer, messageBufferSize);
     if (readNumber<uint8_t>() != 0) {
         throw std::runtime_error("pinata failed to sign this message");
@@ -154,22 +154,22 @@ void PinataClient::dilithiumSign(const uint8_t *messageBuffer, size_t messageBuf
     read(signedMessageBuffer, signedMessageBufferSize);
 }
 
-bool PinataClient::dilithiumVerify(const uint8_t *signatureBuffer, size_t signatureBufferSize) {
-    command(CMD_SW_DILITHIUM_VERIFY);
+bool PinataClient::mldsaVerify(const uint8_t *signatureBuffer, size_t signatureBufferSize) {
+    command(CMD_SW_MLDSA_VERIFY);
     write(signatureBuffer, signatureBufferSize);
     return readNumber<uint8_t>() == 0;
 }
 
-std::pair<int, int> PinataClient::kyber512GetKeySizes() {
-    command(CMD_SW_KYBER512_GET_KEY_SIZES);
+std::pair<int, int> PinataClient::mlkemGetKeySizes() {
+    command(CMD_SW_MLKEM_GET_KEY_SIZES);
     const uint16_t publicKeySize = readNumber<uint16_t>();
     const uint16_t privateKeySize = readNumber<uint16_t>();
     return std::make_pair(publicKeySize, privateKeySize);
 }
 
-void PinataClient::kyber512SetPublicPrivateKeyPair(const uint8_t *publicKey, size_t publicKeySize,
-                                                   const uint8_t *privateKey, size_t privateKeySize) {
-    command(CMD_SW_KYBER512_SET_PUBLIC_AND_PRIVATE_KEY);
+void PinataClient::mlkemSetPublicPrivateKeyPair(const uint8_t *publicKey, size_t publicKeySize,
+                                                const uint8_t *privateKey, size_t privateKeySize) {
+    command(CMD_SW_MLKEM_SET_PUBLIC_AND_PRIVATE_KEY);
     write(publicKey, publicKeySize);
     write(privateKey, privateKeySize);
     if (readNumber<uint8_t>() != 0) {
@@ -177,9 +177,9 @@ void PinataClient::kyber512SetPublicPrivateKeyPair(const uint8_t *publicKey, siz
     }
 }
 
-void PinataClient::kyber512Generate(uint8_t *sharedSecretBuffer, size_t sharedSecretBufferSize,
-                                    uint8_t *keyEncapsulationMessageBuffer, size_t keyEncapsulationMessageBufferSize) {
-    command(CMD_SW_KYBER512_GENERATE);
+void PinataClient::mlkemGenerate(uint8_t *sharedSecretBuffer, size_t sharedSecretBufferSize,
+                                 uint8_t *keyEncapsulationMessageBuffer, size_t keyEncapsulationMessageBufferSize) {
+    command(CMD_SW_MLKEM_GENERATE);
     if (readNumber<uint8_t>() != 0) {
         throw std::runtime_error("failed to generate shared secret");
     }
@@ -187,10 +187,9 @@ void PinataClient::kyber512Generate(uint8_t *sharedSecretBuffer, size_t sharedSe
     read(keyEncapsulationMessageBuffer, keyEncapsulationMessageBufferSize);
 }
 
-void PinataClient::kyber512Decode(const uint8_t *keyEncapsulationMessageBuffer,
-                                  size_t keyEncapsulationMessageBufferSize, uint8_t *sharedSecretBuffer,
-                                  size_t sharedSecretBufferSize) {
-    command(CMD_SW_KYBER512_DEC);
+void PinataClient::mlkemDecode(const uint8_t *keyEncapsulationMessageBuffer, size_t keyEncapsulationMessageBufferSize,
+                               uint8_t *sharedSecretBuffer, size_t sharedSecretBufferSize) {
+    command(CMD_SW_MLKEM_DEC);
     write(keyEncapsulationMessageBuffer, keyEncapsulationMessageBufferSize);
     if (readNumber<uint8_t>() != 0) {
         throw std::runtime_error("failed to decode shared secret");
diff --git a/PinataTests/common.hpp b/PinataTests/common.hpp
index 4c1989b..d354e78 100644
--- a/PinataTests/common.hpp
+++ b/PinataTests/common.hpp
@@ -40,15 +40,15 @@ class PinataClient {
 
     std::pair<int, int> getVersion();
     FirmwareVariant determineFirmwareVariant();
-    std::pair<int, int> dilithiumGetKeySizes();
-    uint8_t dilithiumGetSecurityLevel();
-    void dilithiumSetPublicPrivateKeyPair(const uint8_t* publicKey, size_t publicKeySize, const uint8_t* privateKey, size_t privateKeySize);
-    void dilithiumSign(const uint8_t* messageBuffer, size_t messageBufferSize, uint8_t* signedMessageBuffer, size_t signedMessageBufferSize);
-    bool dilithiumVerify(const uint8_t* signatureBuffer, size_t signatureBufferSize);
-    std::pair<int, int> kyber512GetKeySizes();
-    void kyber512SetPublicPrivateKeyPair(const uint8_t* publicKey, size_t publicKeySize, const uint8_t* privateKey, size_t privateKeySize);
-    void kyber512Generate(uint8_t* sharedSecretBuffer, size_t sharedSecretBufferSize, uint8_t* keyEncapsulationMessageBuffer, size_t keyEncapsulationMessageBufferSize);
-    void kyber512Decode(const uint8_t* keyEncapsulationMessageBuffer, size_t keyEncapsulationMessageBufferSize, uint8_t* sharedSecretBuffer, size_t sharedSecretBufferSize);
+    std::pair<int, int> mldsaGetKeySizes();
+    uint8_t mldsaGetSecurityLevel();
+    void mldsaSetPublicPrivateKeyPair(const uint8_t* publicKey, size_t publicKeySize, const uint8_t* privateKey, size_t privateKeySize);
+    void mldsaSign(const uint8_t* messageBuffer, size_t messageBufferSize, uint8_t* signedMessageBuffer, size_t signedMessageBufferSize);
+    bool mldsaVerify(const uint8_t* signatureBuffer, size_t signatureBufferSize);
+    std::pair<int, int> mlkemGetKeySizes();
+    void mlkemSetPublicPrivateKeyPair(const uint8_t* publicKey, size_t publicKeySize, const uint8_t* privateKey, size_t privateKeySize);
+    void mlkemGenerate(uint8_t* sharedSecretBuffer, size_t sharedSecretBufferSize, uint8_t* keyEncapsulationMessageBuffer, size_t keyEncapsulationMessageBufferSize);
+    void mlkemDecode(const uint8_t* keyEncapsulationMessageBuffer, size_t keyEncapsulationMessageBufferSize, uint8_t* sharedSecretBuffer, size_t sharedSecretBufferSize);
     
     void doSymmetricCipherRequest(const uint8_t cmd, const uint8_t* input, const size_t inputSize, uint8_t* output,const size_t outputSize);
     void SWDESEncrypt(const uint8_t* plaintext, uint8_t* ciphertext);
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index abd6265..3be47ae 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -16,7 +16,7 @@ set(PINATA_VID 0483)
 set(PINATA_DID 2200)
 set(FLASH_TARGET_OFFSET 0x08000000)
 
-option(RANDOM_SIGNING "Enable random signing for Dilithium cipher" OFF)
+option(RANDOM_SIGNING "Enable random signing for ML-DSA cipher" OFF)
 
 # Common lib
 file(GLOB COMMON_SOURCE_FILES
@@ -148,7 +148,7 @@ add_licensed_subdir(prng               "classic;hw" BSD-3-Clause-Clear     https
 add_licensed_subdir(ecc                "classic;hw" BSD-3-Clause-Clear     https://github.com/Riscure/Pinata                           https://github.com/Riscure/Pinata.git)
 add_licensed_subdir(curve25519_CortexM "classic;hw" CC0-1.0                https://munacl.cryptojedi.org/curve25519-cortexm0.shtml     https://munacl.cryptojedi.org/data/curve25519-cortexm0-20150813.tar.bz2)
 add_licensed_subdir(pqm4common         pqc          CC0-1.0                https://github.com/mupq/pqm4                                https://github.com/mupq/pqm4.git)
-add_licensed_subdir(dilithium          pqc          CC0-1.0                https://github.com/mupq/pqm4                                https://github.com/mupq/pqm4.git)
+add_licensed_subdir(ml-dsa             pqc          CC0-1.0                https://github.com/mupq/pqm4                                https://github.com/mupq/pqm4.git)
 add_licensed_subdir(kyber512           pqc          CC0-1.0                https://github.com/mupq/pqm4                                https://github.com/mupq/pqm4.git)
 #                   Subdirectory       Targets      SPDX License           Informational Website                                       Source Code Origin
 
@@ -163,7 +163,7 @@ add_licensed_subdir(
 # Minor tweaks for the firmware targets.
 target_compile_definitions(hw PRIVATE HW_CRYPTO_PRESENT)
 target_include_directories(pqc PRIVATE pqm4common)
-target_compile_definitions(pqc PRIVATE VARIANT_PQC $<$<BOOL:${RANDOM_SIGNING}>:DILITHIUM_RANDOMIZED_SIGNING>)
+target_compile_definitions(pqc PRIVATE VARIANT_PQC $<$<BOOL:${RANDOM_SIGNING}>:MLDSA_RANDOMIZED_SIGNING>)
 
 # After having collected all license information into lists, we now generate
 # the notice file.
diff --git a/src/dilithium/README.md b/src/dilithium/README.md
deleted file mode 100644
index a2a2a33..0000000
--- a/src/dilithium/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
-The code here is based on
-
-https://github.com/mupq/pqm4
-commit: 992f0f226503d43b6d33278ecb60a9168ed8d787
-
-The above commit seems to most closely match "NIST Submission Round 3" of the reference implementation. The reference implementation can be found at
-
-https://github.com/pq-crystals/dilithium
-
-There seems to be no git tag for Round 3. However, there is a git tag for "v3.1". The "NIST Submission Round 3" seems to correspond to the code just before "v3.1".
diff --git a/src/dilithium/poly.h b/src/dilithium/poly.h
deleted file mode 100644
index fc473ac..0000000
--- a/src/dilithium/poly.h
+++ /dev/null
@@ -1,83 +0,0 @@
-#ifndef POLY_H
-#define POLY_H
-
-#include <stdint.h>
-#include "params.h"
-
-typedef struct {
-  int32_t coeffs[N];
-} poly;
-
-#define poly_reduce DILITHIUM_NAMESPACE(poly_reduce)
-void poly_reduce(poly *a);
-#define poly_caddq DILITHIUM_NAMESPACE(poly_caddq)
-void poly_caddq(poly *a);
-#define poly_freeze DILITHIUM_NAMESPACE(poly_freeze)
-void poly_freeze(poly *a);
-
-#define poly_add DILITHIUM_NAMESPACE(poly_add)
-void poly_add(poly *c, const poly *a, const poly *b);
-#define poly_sub DILITHIUM_NAMESPACE(poly_sub)
-void poly_sub(poly *c, const poly *a, const poly *b);
-#define poly_shiftl DILITHIUM_NAMESPACE(poly_shiftl)
-void poly_shiftl(poly *a);
-
-#define poly_ntt DILITHIUM_NAMESPACE(poly_ntt)
-void poly_ntt(poly *a);
-#define poly_invntt_tomont DILITHIUM_NAMESPACE(poly_invntt_tomont)
-void poly_invntt_tomont(poly *a);
-#define poly_pointwise_montgomery DILITHIUM_NAMESPACE(poly_pointwise_montgomery)
-void poly_pointwise_montgomery(poly *c, const poly *a, const poly *b);
-#define poly_pointwise_acc_montgomery DILITHIUM_NAMESPACE(poly_pointwise_acc_montgomery)
-void poly_pointwise_acc_montgomery(poly *c, const poly *a, const poly *b);
-
-#define poly_power2round DILITHIUM_NAMESPACE(poly_power2round)
-void poly_power2round(poly *a1, poly *a0, const poly *a);
-#define poly_decompose DILITHIUM_NAMESPACE(poly_decompose)
-void poly_decompose(poly *a1, poly *a0, const poly *a);
-#define poly_make_hint DILITHIUM_NAMESPACE(poly_make_hint)
-unsigned int poly_make_hint(poly *h, const poly *a0, const poly *a1);
-#define poly_use_hint DILITHIUM_NAMESPACE(poly_use_hint)
-void poly_use_hint(poly *b, const poly *a, const poly *h);
-
-#define poly_chknorm DILITHIUM_NAMESPACE(poly_chknorm)
-int poly_chknorm(const poly *a, int32_t B);
-#define poly_uniform DILITHIUM_NAMESPACE(poly_uniform)
-void poly_uniform(poly *a,
-                  const uint8_t seed[SEEDBYTES],
-                  uint16_t nonce);
-#define poly_uniform_eta DILITHIUM_NAMESPACE(poly_uniform_eta)
-void poly_uniform_eta(poly *a,
-                      const uint8_t seed[SEEDBYTES],
-                      uint16_t nonce);
-#define poly_uniform_gamma1 DILITHIUM_NAMESPACE(poly_uniform_gamma1)
-void poly_uniform_gamma1(poly *a,
-                         const uint8_t seed[CRHBYTES],
-                         uint16_t nonce);
-#define poly_challenge DILITHIUM_NAMESPACE(poly_challenge)
-void poly_challenge(poly *c, const uint8_t seed[SEEDBYTES]);
-
-#define polyeta_pack DILITHIUM_NAMESPACE(polyeta_pack)
-void polyeta_pack(uint8_t *r, const poly *a);
-#define polyeta_unpack DILITHIUM_NAMESPACE(polyeta_unpack)
-void polyeta_unpack(poly *r, const uint8_t *a);
-
-#define polyt1_pack DILITHIUM_NAMESPACE(polyt1_pack)
-void polyt1_pack(uint8_t *r, const poly *a);
-#define polyt1_unpack DILITHIUM_NAMESPACE(polyt1_unpack)
-void polyt1_unpack(poly *r, const uint8_t *a);
-
-#define polyt0_pack DILITHIUM_NAMESPACE(polyt0_pack)
-void polyt0_pack(uint8_t *r, const poly *a);
-#define polyt0_unpack DILITHIUM_NAMESPACE(polyt0_unpack)
-void polyt0_unpack(poly *r, const uint8_t *a);
-
-#define polyz_pack DILITHIUM_NAMESPACE(polyz_pack)
-void polyz_pack(uint8_t *r, const poly *a);
-#define polyz_unpack DILITHIUM_NAMESPACE(polyz_unpack)
-void polyz_unpack(poly *r, const uint8_t *a);
-
-#define polyw1_pack DILITHIUM_NAMESPACE(polyw1_pack)
-void polyw1_pack(uint8_t *r, const poly *a);
-
-#endif
diff --git a/src/dilithium/wrapper.c b/src/dilithium/wrapper.c
deleted file mode 100755
index 942ae78..0000000
--- a/src/dilithium/wrapper.c
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "./wrapper.h"
-#include "./params.h"
-#include "./api.h"
-#include "./sign.h"
-#include "./poly.h"
-#include <string.h>
-
-#if DILITHIUM_PUBLIC_KEY_SIZE != CRYPTO_PUBLICKEYBYTES
-#error invalid public key size, update me!
-#endif
-#if DILITHIUM_PRIVATE_KEY_SIZE != CRYPTO_SECRETKEYBYTES
-#error invalid private key size, update me!
-#endif
-#if DILITHIUM_SIGNATURE_SIZE != CRYPTO_BYTES
-#error invalid signature size, update me!
-#endif
-#if DILITHIUM_N != N
-#error invalid N, update me!
-#endif
-
-int getDilithiumAlgorithmVariant() {
-	return DILITHIUM_MODE;
-}
-
-uint8_t* DilithiumState_getPrivateKey(DilithiumState* self) {
-	return self->m_sk;
-}
-
-uint8_t* DilithiumState_getPublicKey(DilithiumState* self) {
-	return self->m_pk;
-}
-
-uint8_t* DilithiumState_getScratchPad(DilithiumState* self) {
-	return self->m_scratchpad;
-}
-
-int DilithiumState_verify(const DilithiumState* self, uint8_t *signedMessage) {
-	size_t messageLength = DILITHIUM_MESSAGE_SIZE;
-	return crypto_sign_open(signedMessage, &messageLength, signedMessage, DILITHIUM_SIGNED_MESSAGE_SIZE, self->m_pk);
-}
-
-int DilithiumState_sign(const DilithiumState* self, uint8_t* signature, const uint8_t* message) {
-	size_t signatureSize = DILITHIUM_SIGNATURE_SIZE;
-	return crypto_sign_signature(signature, &signatureSize, message, DILITHIUM_MESSAGE_SIZE, self->m_sk);
-}
-
-int Dilithium_ntt(uint32_t* coefficients) {
-	poly* coeffs = (poly*)coefficients;
-	poly_ntt(coeffs);
-	return 0;
-}
diff --git a/src/dilithium/wrapper.h b/src/dilithium/wrapper.h
deleted file mode 100755
index 5952b0e..0000000
--- a/src/dilithium/wrapper.h
+++ /dev/null
@@ -1,93 +0,0 @@
-#ifndef _DILITHIUM_WRAPPER_H_
-#define _DILITHIUM_WRAPPER_H_
-
-#include <stdint.h>
-#include <stddef.h>
-
-#define DILITHIUM_PUBLIC_KEY_SIZE 1952
-#define DILITHIUM_PRIVATE_KEY_SIZE 4016
-#define DILITHIUM_SIGNATURE_SIZE 3293
-#define DILITHIUM_MESSAGE_SIZE 16
-#define DILITHIUM_N 256
-#define DILITHIUM_SIGNED_MESSAGE_SIZE (DILITHIUM_SIGNATURE_SIZE + DILITHIUM_MESSAGE_SIZE)
-
-/**
- * @brief      Get the dilithium algorithm variant. There are a few variants and
- *             only one of them is implemented.
- *
- * @return     The dilithium algorithm variant.
- */
-int getDilithiumAlgorithmVariant();
-
-/**
- * Simple object-oriented wrapper around the various Dilithium functions.
- * All "methods" start with the prefix "DilithiumState_".
- */
-typedef struct DilithiumState_t {
-	uint8_t m_pk[DILITHIUM_PUBLIC_KEY_SIZE];
-	uint8_t m_sk[DILITHIUM_PRIVATE_KEY_SIZE];
-    uint8_t m_scratchpad[DILITHIUM_SIGNED_MESSAGE_SIZE];
-} DilithiumState;
-
-/**
- * @brief      Get the private key bytes.
- *
- * @param[in]  self  The object
- *
- * @return     The private key bytes.
- */
-uint8_t* DilithiumState_getPrivateKey(DilithiumState* self);
-
-/**
- * @brief      Get the public key bytes.
- *
- * @param[in]  self  The object
- *
- * @return     The public key bytes.
- */
-uint8_t* DilithiumState_getPublicKey(DilithiumState* self);
-
-/**
- * @brief      Get the "scratch pad" for message storage, signature storage.
- *
- * @param      self  The object
- *
- * @return     Pointer to the scratch pad.
- */
-uint8_t* DilithiumState_getScratchPad(DilithiumState* self);
-
-/**
- * @brief      Verify a signed message.
- *
- * @param[in]  self           The object
- * @param[in]  signature      Buffer of the signed message. This buffer MUST have
- *                            length DILITHIUM_SIGNATURE_SIZE + DILITHIUM_MESSAGE_SIZE.
- *
- * @return     0 when verification passes, non-zero otherwise.
- */
-int DilithiumState_verify(const DilithiumState* self, uint8_t *signedMessage);
-
-/**
- * @brief      Sign a message.
- *
- * @param[in]  self           The object
- * @param[out] signature      Buffer where the signature will be placed in. This
- *                            buffer MUST have length DILITHIUM_SIGNATURE_SIZE.
- * @param[in]  message        Buffer of the message to be signed. This buffer MUST
- *                            have length DILITHIUM_MESSAGE_SIZE.
- *
- * @return     0 when signing succeeds, non-zero otherwise.
- */
-int DilithiumState_sign(const DilithiumState* self, uint8_t* signature, const uint8_t* message);
-
-///
-/// @brief        Perform a forward NTT.
-///
-/// @param[inout] coefficients  Buffer of polynomial coefficients in integer
-///                             domain. The computation is done in-place, and
-///                             this array contains the coefficients in the
-///                             frequency domain after this function returns.
-///
-int Dilithium_ntt(uint32_t *coefficients);
-
-#endif // _DILITHIUM_WRAPPER_H_
diff --git a/src/main.c b/src/main.c
index 86a4770..97f4bde 100755
--- a/src/main.c
+++ b/src/main.c
@@ -60,7 +60,7 @@
 #include "io.h"
 
 #ifdef VARIANT_PQC
-#include "dilithium/wrapper.h"
+#include "ml-dsa/wrapper.h"
 #include "kyber512/wrapper.h"
 #endif
 
@@ -97,7 +97,7 @@ uint8_t rxBuffer[RXBUFFERLENGTH] = {};
 const uint8_t zeros[20]={'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};
 const uint8_t glitched[] = { 0xFA, 0xCC };
 const uint8_t cmdByteIsWrong[] = { 'B','a','d','C','m','d','\n',0x00};
-const uint8_t codeVersion[] = { 'V','e','r',' ','3','.','2',0x00};
+const uint8_t codeVersion[] = { 'V','e','r',' ','4','.','0',0x00};
 
 volatile uint8_t usbSerialEnabled=0;
 volatile int busyWait1;
@@ -113,7 +113,7 @@ unsigned char etxBuf[256] ={};
 #define END_INTERESTING_STUFF GPIOC->BSRRH = GPIO_Pin_2
 
 #ifdef VARIANT_PQC
-DilithiumState dilithium;
+MldsaState mldsa;
 Kyber512State kyber512;
 #endif
 
@@ -238,29 +238,29 @@ int main(void) {
 
 #ifdef VARIANT_PQC
 
-			case CMD_SW_DILITHIUM_GET_VARIANT:
+			case CMD_SW_MLDSA_GET_VARIANT:
 				// Return the response.
-				send_char(getDilithiumAlgorithmVariant());
+				send_char(getMldsaAlgorithmVariant());
 				break;
 
-			case CMD_SW_DILITHIUM_SET_PUBLIC_AND_PRIVATE_KEY: {
+			case CMD_SW_MLDSA_SET_PUBLIC_AND_PRIVATE_KEY: {
 				// Receive the input parameters and handle the request.
-				get_bytes(DILITHIUM_PUBLIC_KEY_SIZE, DilithiumState_getPublicKey(&dilithium));
-				get_bytes(DILITHIUM_PRIVATE_KEY_SIZE, DilithiumState_getPrivateKey(&dilithium));
+				get_bytes(MLDSA_PUBLIC_KEY_SIZE, MldsaState_getPublicKey(&mldsa));
+				get_bytes(MLDSA_PRIVATE_KEY_SIZE, MldsaState_getPrivateKey(&mldsa));
 
 				// Return the response.
 				send_char(0);
 				break;
 			}
 
-			case CMD_SW_DILITHIUM_VERIFY: {
+			case CMD_SW_MLDSA_VERIFY: {
 				// Receive the input parameters.
-				uint8_t* signedMessageBuffer = DilithiumState_getScratchPad(&dilithium);
-				get_bytes(DILITHIUM_SIGNED_MESSAGE_SIZE, signedMessageBuffer);
+				uint8_t* signedMessageBuffer = MldsaState_getScratchPad(&mldsa);
+				get_bytes(MLDSA_SIGNED_MESSAGE_SIZE, signedMessageBuffer);
 
 				// Handle the request.
 				BEGIN_INTERESTING_STUFF;
-				int result = DilithiumState_verify(&dilithium, signedMessageBuffer);
+				int result = MldsaState_verify(&mldsa, signedMessageBuffer);
 				END_INTERESTING_STUFF;
 
 				// Return the response.
@@ -268,20 +268,20 @@ int main(void) {
 				break;	
 			}
 
-			case CMD_SW_DILITHIUM_SIGN: {
+			case CMD_SW_MLDSA_SIGN: {
 				// Receive the input parameters.
-				uint8_t* signedMessageBuffer = DilithiumState_getScratchPad(&dilithium);
-				get_bytes(DILITHIUM_MESSAGE_SIZE, signedMessageBuffer + DILITHIUM_SIGNATURE_SIZE);
+				uint8_t* signedMessageBuffer = MldsaState_getScratchPad(&mldsa);
+				get_bytes(MLDSA_MESSAGE_SIZE, signedMessageBuffer + MLDSA_SIGNATURE_SIZE);
 
 				// Handle the request.
 				BEGIN_INTERESTING_STUFF;
-				int result = DilithiumState_sign(&dilithium, signedMessageBuffer, signedMessageBuffer + DILITHIUM_SIGNATURE_SIZE);
+				int result = MldsaState_sign(&mldsa, signedMessageBuffer, signedMessageBuffer + MLDSA_SIGNATURE_SIZE);
 				END_INTERESTING_STUFF;
 
 				if (result == 0) {
 					// OK: The message is now signed, let's send the signature of the message back.
 					send_char(0);
-					send_bytes(DILITHIUM_SIGNATURE_SIZE, signedMessageBuffer);
+					send_bytes(MLDSA_SIGNATURE_SIZE, signedMessageBuffer);
 				} else {
 					// ERROR: Signing the message failed.
 					send_char(1);
@@ -289,21 +289,21 @@ int main(void) {
 				break;
 			}
 
-			case CMD_SW_DILITHIUM_GET_KEY_SIZES: {
-				const uint16_t publicKeySize = DILITHIUM_PUBLIC_KEY_SIZE;
-				const uint16_t privateKeySize = DILITHIUM_PRIVATE_KEY_SIZE;
+			case CMD_SW_MLDSA_GET_KEY_SIZES: {
+				const uint16_t publicKeySize = MLDSA_PUBLIC_KEY_SIZE;
+				const uint16_t privateKeySize = MLDSA_PRIVATE_KEY_SIZE;
 				// Send the response; MUST be in little-endian order!
 				send_bytes(sizeof(publicKeySize), (const uint8_t*)&publicKeySize);
 				send_bytes(sizeof(privateKeySize), (const uint8_t*)&privateKeySize);
 				break;
 			}
 
-			case CMD_SW_DILITHIUM_NTT: {
-				int32_t polynomialBuffer[DILITHIUM_N];
+			case CMD_SW_MLDSA_NTT: {
+				int32_t polynomialBuffer[MLDSA_N];
 				// Receive the polynomial coefficients.
-				get_bytes(sizeof(int32_t)*DILITHIUM_N, (uint8_t*)polynomialBuffer);
+				get_bytes(sizeof(int32_t)*MLDSA_N, (uint8_t*)polynomialBuffer);
 				BEGIN_INTERESTING_STUFF;
-				Dilithium_ntt(polynomialBuffer);
+				Mldsa_ntt(polynomialBuffer);
 				END_INTERESTING_STUFF;
 				// No reply is sent.
 				break;
diff --git a/src/main.h b/src/main.h
index baa1c1c..6657395 100755
--- a/src/main.h
+++ b/src/main.h
@@ -39,7 +39,7 @@
 #include "sm4/sm4.h"
 #include "tea/tea.h"
 #include "present/present.h"
-#include "dilithium/wrapper.h"
+#include "ml-dsa/wrapper.h"
 #endif
 
 //ANSSI AES - see https://github.com/ANSSI-FR/SecAESSTM32
@@ -160,51 +160,51 @@
 #define CMD_SWXTEA_ENC 0x6E
 #define CMD_SWXTEA_DEC 0x6F
 
-/// Return the Dilithium algorithm variant used in this implementation.
-/// The variant is one of the identifiers 1, 2, 3 or 4.
+/// Return the MLDSA algorithm variant used in this implementation.
+/// The variant is one of the identifiers 44, 65 or 87.
 ///
 /// Expected Input:
 ///   None
 ///
 /// Output:
-///   A single byte whose value is the Dilithium variant.
-#define CMD_SW_DILITHIUM_GET_VARIANT 0x90
+///   A single byte whose value is the MLDSA variant.
+#define CMD_SW_MLDSA_GET_VARIANT 0x90
 
-/// Set the public and private key for the Dilithium crypto-system.
+/// Set the public and private key for the MLDSA crypto-system.
 /// The public and private key MUST be valid. No validation is
 /// done by the Pinata.
 ///
 /// Expected Input:
-///   public key bytes of size DILITHIUM_PUBLIC_KEY_SIZE, followed by
-///   private key bytes of size DILITHIUM_PRIVATE_KEY_SIZE.
+///   public key bytes of size MLDSA_PUBLIC_KEY_SIZE, followed by
+///   private key bytes of size MLDSA_PRIVATE_KEY_SIZE.
 ///
 /// Output:
 ///   One byte; the byte is always zero.
-#define CMD_SW_DILITHIUM_SET_PUBLIC_AND_PRIVATE_KEY 0x91
+#define CMD_SW_MLDSA_SET_PUBLIC_AND_PRIVATE_KEY 0x91
 
 /// Verify a signed message, using the public key provided via
-/// CMD_SW_DILITHIUM_SET_PUBLIC_AND_PRIVATE_KEY.
+/// CMD_SW_MLDSA_SET_PUBLIC_AND_PRIVATE_KEY.
 ///
 /// Expected Input:
-///   Signature of length DILITHIUM_SIGNATURE_SIZE, followed by
-///   Message of length PINATA_DILITHIUM_MESSAGE_LENGTH
+///   Signature of length MLDSA_SIGNATURE_SIZE, followed by
+///   Message of length PINATA_MLDSA_MESSAGE_LENGTH
 ///
-///   (in other words, a "signed message" of size PINATA_DILITHIUM_SIGNED_MESSAGE_SIZE).
+///   (in other words, a "signed message" of size PINATA_MLDSA_SIGNED_MESSAGE_SIZE).
 ///
 /// Output:
 ///   One byte; the byte is 0 if the signature of the message is valid,
 ///   non-zero otherwise.
-#define CMD_SW_DILITHIUM_VERIFY 0x92
+#define CMD_SW_MLDSA_VERIFY 0x92
 
 /// Sign a message, using the private key provided via
-/// CMD_SW_DILITHIUM_SET_PUBLIC_AND_PRIVATE_KEY.
+/// CMD_SW_MLDSA_SET_PUBLIC_AND_PRIVATE_KEY.
 ///
 /// Expected Input:
-///   message of length PINATA_DILITHIUM_MESSAGE_LENGTH bytes.
+///   message of length PINATA_MLDSA_MESSAGE_LENGTH bytes.
 ///
 /// Output:
-///   Signature of the message. The signature has size DILITHIUM_SIGNATURE_SIZE.
-#define CMD_SW_DILITHIUM_SIGN 0x93
+///   Signature of the message. The signature has size MLDSA_SIGNATURE_SIZE.
+#define CMD_SW_MLDSA_SIGN 0x93
 
 /// Get the public and private key sizes.
 ///
@@ -214,16 +214,16 @@
 /// Output:
 ///   16-bit unsigned integer in little endian order that contains the public key size, followed by
 ///   16-bit unsigned integer in little endian order that contains the private key size
-#define CMD_SW_DILITHIUM_GET_KEY_SIZES 0x94
+#define CMD_SW_MLDSA_GET_KEY_SIZES 0x94
 
-/// Perform Dilithium NTT.
+/// Perform MLDSA NTT.
 ///
 /// Expected Input:
-///   A total of DILITHIUM_N 32-bit integers in little endian order.
+///   A total of MLDSA_N 32-bit integers in little endian order.
 ///
 /// Output:
 ///   No reply is sent back.
-#define CMD_SW_DILITHIUM_NTT 0x9A
+#define CMD_SW_MLDSA_NTT 0x9A
 
 #define CMD_SWDES_ENC_MISALIGNED 0x14
 #define CMD_SWAES128_ENC_MISALIGNED 0x1E
diff --git a/src/dilithium/CMakeLists.txt b/src/ml-dsa/CMakeLists.txt
similarity index 100%
rename from src/dilithium/CMakeLists.txt
rename to src/ml-dsa/CMakeLists.txt
diff --git a/src/ml-dsa/README.md b/src/ml-dsa/README.md
new file mode 100644
index 0000000..0c9cc56
--- /dev/null
+++ b/src/ml-dsa/README.md
@@ -0,0 +1,10 @@
+The code here was originally based on
+
+https://github.com/mupq/pqm4
+commit: 992f0f226503d43b6d33278ecb60a9168ed8d787
+
+The above commit seems to most closely match "NIST Submission Round 3" of the reference implementation for Dilithium. The reference implementation can be found at
+
+https://github.com/pq-crystals/dilithium
+
+However, the code was then updated for ML-DSA, the official NIST standard for which Dilithium was just the in-progress working name.
diff --git a/src/dilithium/api.h b/src/ml-dsa/api.h
similarity index 100%
rename from src/dilithium/api.h
rename to src/ml-dsa/api.h
diff --git a/src/dilithium/config.h b/src/ml-dsa/config.h
similarity index 75%
rename from src/dilithium/config.h
rename to src/ml-dsa/config.h
index 5572407..cf9a748 100644
--- a/src/dilithium/config.h
+++ b/src/ml-dsa/config.h
@@ -1,7 +1,7 @@
 #ifndef CONFIG_H
 #define CONFIG_H
 
-#define DILITHIUM_MODE 3
+#define MLDSA_MODE 65
 // #define SIGN_STACKSTRATEGY 2
 
 #endif
diff --git a/src/dilithium/macros.i b/src/ml-dsa/macros.i
similarity index 100%
rename from src/dilithium/macros.i
rename to src/ml-dsa/macros.i
diff --git a/src/dilithium/macros_fnt.i b/src/ml-dsa/macros_fnt.i
similarity index 100%
rename from src/dilithium/macros_fnt.i
rename to src/ml-dsa/macros_fnt.i
diff --git a/src/dilithium/ntt.S b/src/ml-dsa/ntt.S
similarity index 98%
rename from src/dilithium/ntt.S
rename to src/ml-dsa/ntt.S
index 53a36bc..d18aaa9 100644
--- a/src/dilithium/ntt.S
+++ b/src/ml-dsa/ntt.S
@@ -39,11 +39,11 @@ smlad r0,r0,r0,r0
   add.w \pol0, \pol0, \th
 .endm
 
-//void pqcrystals_dilithium_ntt(int32_t p[N]);
-.global pqcrystals_dilithium_ntt
-.type pqcrystals_dilithium_ntt,%function
+//void pqcrystals_mldsa_ntt(int32_t p[N]);
+.global pqcrystals_mldsa_ntt
+.type pqcrystals_mldsa_ntt,%function
 .align 2
-pqcrystals_dilithium_ntt:
+pqcrystals_mldsa_ntt:
   //bind aliases
   ptr_p     .req R0
   ptr_zeta  .req R1
@@ -308,11 +308,11 @@ pqcrystals_dilithium_ntt:
   smlal \y, \pol, \x, \q
 .endm
 
-//void pqcrystals_dilithium_invntt_tomont(int32_t p[N]);
-.global pqcrystals_dilithium_invntt_tomont
-.type pqcrystals_dilithium_invntt_tomont,%function
+//void pqcrystals_mldsa_invntt_tomont(int32_t p[N]);
+.global pqcrystals_mldsa_invntt_tomont
+.type pqcrystals_mldsa_invntt_tomont,%function
 .align 2
-pqcrystals_dilithium_invntt_tomont:
+pqcrystals_mldsa_invntt_tomont:
   //bind aliases
   ptr_p     .req R0
   ptr_zeta  .req R1
diff --git a/src/dilithium/ntt.h b/src/ml-dsa/ntt.h
similarity index 59%
rename from src/dilithium/ntt.h
rename to src/ml-dsa/ntt.h
index 731132d..624180c 100644
--- a/src/dilithium/ntt.h
+++ b/src/ml-dsa/ntt.h
@@ -4,10 +4,10 @@
 #include <stdint.h>
 #include "params.h"
 
-#define ntt DILITHIUM_NAMESPACE(ntt)
+#define ntt MLDSA_NAMESPACE(ntt)
 void ntt(int32_t a[N]);
 
-#define invntt_tomont DILITHIUM_NAMESPACE(invntt_tomont)
+#define invntt_tomont MLDSA_NAMESPACE(invntt_tomont)
 void invntt_tomont(int32_t a[N]);
 
 #endif
diff --git a/src/dilithium/packing.c b/src/ml-dsa/packing.c
similarity index 90%
rename from src/dilithium/packing.c
rename to src/ml-dsa/packing.c
index ae463d1..de9bdef 100644
--- a/src/dilithium/packing.c
+++ b/src/ml-dsa/packing.c
@@ -64,7 +64,7 @@ void unpack_pk(uint8_t rho[SEEDBYTES],
 **************************************************/
 void pack_sk(uint8_t sk[CRYPTO_SECRETKEYBYTES],
              const uint8_t rho[SEEDBYTES],
-             const uint8_t tr[CRHBYTES],
+             const uint8_t tr[TRBYTES],
              const uint8_t key[SEEDBYTES],
              const polyveck *t0,
              const polyvecl *s1,
@@ -80,9 +80,9 @@ void pack_sk(uint8_t sk[CRYPTO_SECRETKEYBYTES],
     sk[i] = key[i];
   sk += SEEDBYTES;
 
-  for(i = 0; i < CRHBYTES; ++i)
+  for(i = 0; i < TRBYTES; ++i)
     sk[i] = tr[i];
-  sk += CRHBYTES;
+  sk += TRBYTES;
 
   for(i = 0; i < L; ++i)
     polyeta_pack(sk + i*POLYETA_PACKEDBYTES, &s1->vec[i]);
@@ -101,16 +101,16 @@ void pack_sk(uint8_t sk[CRYPTO_SECRETKEYBYTES],
 *
 * Description: Unpack secret key sk = (rho, tr, key, t0, s1, s2).
 *
-* Arguments:   - const uint8_t rho[]: output byte array for rho
-*              - const uint8_t tr[]: output byte array for tr
-*              - const uint8_t key[]: output byte array for key
-*              - const polyveck *t0: pointer to output vector t0
-*              - const polyvecl *s1: pointer to output vector s1
-*              - const polyveck *s2: pointer to output vector s2
-*              - uint8_t sk[]: byte array containing bit-packed sk
+* Arguments:   - uint8_t rho[]: output byte array for rho
+*              - uint8_t tr[]: output byte array for tr
+*              - uint8_t key[]: output byte array for key
+*              - polyveck *t0: pointer to output vector t0
+*              - polyvecl *s1: pointer to output vector s1
+*              - polyveck *s2: pointer to output vector s2
+*              - const uint8_t sk[]: byte array containing bit-packed sk
 **************************************************/
 void unpack_sk(uint8_t rho[SEEDBYTES],
-               uint8_t tr[CRHBYTES],
+               uint8_t tr[TRBYTES],
                uint8_t key[SEEDBYTES],
                polyveck *t0,
                polyvecl *s1,
@@ -127,9 +127,9 @@ void unpack_sk(uint8_t rho[SEEDBYTES],
     key[i] = sk[i];
   sk += SEEDBYTES;
 
-  for(i = 0; i < CRHBYTES; ++i)
+  for(i = 0; i < TRBYTES; ++i)
     tr[i] = sk[i];
-  sk += CRHBYTES;
+  sk += TRBYTES;
 
   for(i=0; i < L; ++i)
     polyeta_unpack(&s1->vec[i], sk + i*POLYETA_PACKEDBYTES);
diff --git a/src/dilithium/packing.h b/src/ml-dsa/packing.h
similarity index 72%
rename from src/dilithium/packing.h
rename to src/ml-dsa/packing.h
index be75aaa..4cf9c55 100644
--- a/src/dilithium/packing.h
+++ b/src/ml-dsa/packing.h
@@ -5,34 +5,34 @@
 #include "params.h"
 #include "polyvec.h"
 
-#define pack_pk DILITHIUM_NAMESPACE(pack_pk)
+#define pack_pk MLDSA_NAMESPACE(pack_pk)
 void pack_pk(uint8_t pk[CRYPTO_PUBLICKEYBYTES], const uint8_t rho[SEEDBYTES], const polyveck *t1);
 
-#define pack_sk DILITHIUM_NAMESPACE(pack_sk)
+#define pack_sk MLDSA_NAMESPACE(pack_sk)
 void pack_sk(uint8_t sk[CRYPTO_SECRETKEYBYTES],
              const uint8_t rho[SEEDBYTES],
-             const uint8_t tr[CRHBYTES],
+             const uint8_t tr[TRBYTES],
              const uint8_t key[SEEDBYTES],
              const polyveck *t0,
              const polyvecl *s1,
              const polyveck *s2);
 
-#define pack_sig DILITHIUM_NAMESPACE(pack_sig)
+#define pack_sig MLDSA_NAMESPACE(pack_sig)
 void pack_sig(uint8_t sig[CRYPTO_BYTES], const uint8_t c[SEEDBYTES], const polyvecl *z, const polyveck *h);
 
-#define unpack_pk DILITHIUM_NAMESPACE(unpack_pk)
+#define unpack_pk MLDSA_NAMESPACE(unpack_pk)
 void unpack_pk(uint8_t rho[SEEDBYTES], polyveck *t1, const uint8_t pk[CRYPTO_PUBLICKEYBYTES]);
 
-#define unpack_sk DILITHIUM_NAMESPACE(unpack_sk)
+#define unpack_sk MLDSA_NAMESPACE(unpack_sk)
 void unpack_sk(uint8_t rho[SEEDBYTES],
-               uint8_t tr[CRHBYTES],
+               uint8_t tr[TRBYTES],
                uint8_t key[SEEDBYTES],
                polyveck *t0,
                polyvecl *s1,
                polyveck *s2,
                const uint8_t sk[CRYPTO_SECRETKEYBYTES]);
 
-#define unpack_sig DILITHIUM_NAMESPACE(unpack_sig)
+#define unpack_sig MLDSA_NAMESPACE(unpack_sig)
 int unpack_sig(uint8_t c[SEEDBYTES], polyvecl *z, polyveck *h, const uint8_t sig[CRYPTO_BYTES]);
 
 #endif
diff --git a/src/dilithium/params.h b/src/ml-dsa/params.h
similarity index 73%
rename from src/dilithium/params.h
rename to src/ml-dsa/params.h
index db3eb21..3dac082 100644
--- a/src/dilithium/params.h
+++ b/src/ml-dsa/params.h
@@ -3,17 +3,18 @@
 
 #include "config.h"
 
-#define DILITHIUM_NAMESPACE(s) pqcrystals_dilithium_##s
+#define MLDSA_NAMESPACE(s) pqcrystals_mldsa_##s
 
 
 #define SEEDBYTES 32
-#define CRHBYTES 48
+#define CRHBYTES 64
+#define TRBYTES 64
 #define N 256
 #define Q 8380417
 #define D 13
 #define ROOT_OF_UNITY 1753
 
-#if DILITHIUM_MODE == 2
+#if MLDSA_MODE == 44
 #define K 4
 #define L 4
 #define ETA 2
@@ -22,9 +23,10 @@
 #define GAMMA1 (1 << 17)
 #define GAMMA2 ((Q-1)/88)
 #define OMEGA 80
-#define CRYPTO_ALGNAME "Dilithium2"
+#define CRYPTO_ALGNAME "Mldsa-44"
+#define CTILDEBYTES 32
 
-#elif DILITHIUM_MODE == 3
+#elif MLDSA_MODE == 65
 #define K 6
 #define L 5
 #define ETA 4
@@ -33,9 +35,10 @@
 #define GAMMA1 (1 << 19)
 #define GAMMA2 ((Q-1)/32)
 #define OMEGA 55
-#define CRYPTO_ALGNAME "Dilithium3"
+#define CRYPTO_ALGNAME "Mldsa-65"
+#define CTILDEBYTES 48
 
-#elif DILITHIUM_MODE == 5
+#elif MLDSA_MODE == 87
 #define K 8
 #define L 7
 #define ETA 2
@@ -44,7 +47,8 @@
 #define GAMMA1 (1 << 19)
 #define GAMMA2 ((Q-1)/32)
 #define OMEGA 75
-#define CRYPTO_ALGNAME "Dilithium5"
+#define CRYPTO_ALGNAME "Mldsa-87"
+#define CTILDEBYTES 64
 
 #endif
 
@@ -71,10 +75,10 @@
 #endif
 
 #define CRYPTO_PUBLICKEYBYTES (SEEDBYTES + K*POLYT1_PACKEDBYTES)
-#define CRYPTO_SECRETKEYBYTES (2*SEEDBYTES + CRHBYTES \
+#define CRYPTO_SECRETKEYBYTES (2*SEEDBYTES + TRBYTES \
                                + L*POLYETA_PACKEDBYTES \
                                + K*POLYETA_PACKEDBYTES \
                                + K*POLYT0_PACKEDBYTES)
-#define CRYPTO_BYTES (SEEDBYTES + L*POLYZ_PACKEDBYTES + POLYVECH_PACKEDBYTES)
+#define CRYPTO_BYTES (CTILDEBYTES + L*POLYZ_PACKEDBYTES + POLYVECH_PACKEDBYTES)
 
 #endif
diff --git a/src/dilithium/pointwise_mont.h b/src/ml-dsa/pointwise_mont.h
similarity index 62%
rename from src/dilithium/pointwise_mont.h
rename to src/ml-dsa/pointwise_mont.h
index 2647a11..94def8d 100644
--- a/src/dilithium/pointwise_mont.h
+++ b/src/ml-dsa/pointwise_mont.h
@@ -5,9 +5,9 @@
 #include "params.h"
 
 
-#define asm_pointwise_montgomery DILITHIUM_NAMESPACE(asm_pointwise_montgomery)
+#define asm_pointwise_montgomery MLDSA_NAMESPACE(asm_pointwise_montgomery)
 void asm_pointwise_montgomery(int32_t c[N], const int32_t a[N], const int32_t b[N]);
-#define asm_pointwise_acc_montgomery DILITHIUM_NAMESPACE(asm_pointwise_acc_montgomery)
+#define asm_pointwise_acc_montgomery MLDSA_NAMESPACE(asm_pointwise_acc_montgomery)
 void asm_pointwise_acc_montgomery(int32_t c[N], const int32_t a[N], const int32_t b[N]);
 
 #endif
diff --git a/src/dilithium/pointwise_mont.s b/src/ml-dsa/pointwise_mont.s
similarity index 83%
rename from src/dilithium/pointwise_mont.s
rename to src/ml-dsa/pointwise_mont.s
index e21125d..2bc7a80 100644
--- a/src/dilithium/pointwise_mont.s
+++ b/src/ml-dsa/pointwise_mont.s
@@ -9,10 +9,10 @@
 
 
 // void asm_pointwise_montgomery(int32_t c[N], const int32_t a[N], const int32_t b[N]);
-.global pqcrystals_dilithium_asm_pointwise_montgomery
-.type pqcrystals_dilithium_asm_pointwise_montgomery,%function
+.global pqcrystals_mldsa_asm_pointwise_montgomery
+.type pqcrystals_mldsa_asm_pointwise_montgomery,%function
 .align 2
-pqcrystals_dilithium_asm_pointwise_montgomery:
+pqcrystals_mldsa_asm_pointwise_montgomery:
     push.w {r4-r11, r14}
     c_ptr .req r0
     a_ptr .req r1
@@ -61,13 +61,13 @@ pqcrystals_dilithium_asm_pointwise_montgomery:
     str.w res, [c_ptr]
 
     pop.w {r4-r11, pc}
-.size pqcrystals_dilithium_asm_pointwise_montgomery, .-pqcrystals_dilithium_asm_pointwise_montgomery
+.size pqcrystals_mldsa_asm_pointwise_montgomery, .-pqcrystals_mldsa_asm_pointwise_montgomery
 
 // void asm_pointwise_acc_montgomery(int32_t c[N], const int32_t a[N], const int32_t b[N]);
-.global pqcrystals_dilithium_asm_pointwise_acc_montgomery
-.type pqcrystals_dilithium_asm_pointwise_acc_montgomery,%function
+.global pqcrystals_mldsa_asm_pointwise_acc_montgomery
+.type pqcrystals_mldsa_asm_pointwise_acc_montgomery,%function
 .align 2
-pqcrystals_dilithium_asm_pointwise_acc_montgomery:
+pqcrystals_mldsa_asm_pointwise_acc_montgomery:
     push.w {r4-r11, r14}
     c_ptr .req r0
     a_ptr .req r1
@@ -125,4 +125,4 @@ pqcrystals_dilithium_asm_pointwise_acc_montgomery:
     str.w res, [c_ptr]
 
     pop.w {r4-r11, pc}
-.size pqcrystals_dilithium_asm_pointwise_acc_montgomery, .-pqcrystals_dilithium_asm_pointwise_acc_montgomery
+.size pqcrystals_mldsa_asm_pointwise_acc_montgomery, .-pqcrystals_mldsa_asm_pointwise_acc_montgomery
diff --git a/src/dilithium/poly.c b/src/ml-dsa/poly.c
similarity index 99%
rename from src/dilithium/poly.c
rename to src/ml-dsa/poly.c
index 85f94f1..acc1233 100644
--- a/src/dilithium/poly.c
+++ b/src/ml-dsa/poly.c
@@ -442,12 +442,12 @@ void poly_uniform_eta(poly *a,
 *              of SHAKE256(seed|nonce) or AES256CTR(seed,nonce).
 *
 * Arguments:   - poly *a: pointer to output polynomial
-*              - const uint8_t seed[]: byte array with seed of length CRHBYTES
+*              - const uint8_t seed[]: byte array with seed of length TRBYTES
 *              - uint16_t nonce: 16-bit nonce
 **************************************************/
 #define POLY_UNIFORM_GAMMA1_NBLOCKS ((POLYZ_PACKEDBYTES + STREAM256_BLOCKBYTES - 1)/STREAM256_BLOCKBYTES)
 void poly_uniform_gamma1(poly *a,
-                         const uint8_t seed[CRHBYTES],
+                         const uint8_t seed[TRBYTES],
                          uint16_t nonce)
 {
   uint8_t buf[POLY_UNIFORM_GAMMA1_NBLOCKS*STREAM256_BLOCKBYTES];
diff --git a/src/ml-dsa/poly.h b/src/ml-dsa/poly.h
new file mode 100644
index 0000000..74b85b5
--- /dev/null
+++ b/src/ml-dsa/poly.h
@@ -0,0 +1,83 @@
+#ifndef POLY_H
+#define POLY_H
+
+#include <stdint.h>
+#include "params.h"
+
+typedef struct {
+  int32_t coeffs[N];
+} poly;
+
+#define poly_reduce MLDSA_NAMESPACE(poly_reduce)
+void poly_reduce(poly *a);
+#define poly_caddq MLDSA_NAMESPACE(poly_caddq)
+void poly_caddq(poly *a);
+#define poly_freeze MLDSA_NAMESPACE(poly_freeze)
+void poly_freeze(poly *a);
+
+#define poly_add MLDSA_NAMESPACE(poly_add)
+void poly_add(poly *c, const poly *a, const poly *b);
+#define poly_sub MLDSA_NAMESPACE(poly_sub)
+void poly_sub(poly *c, const poly *a, const poly *b);
+#define poly_shiftl MLDSA_NAMESPACE(poly_shiftl)
+void poly_shiftl(poly *a);
+
+#define poly_ntt MLDSA_NAMESPACE(poly_ntt)
+void poly_ntt(poly *a);
+#define poly_invntt_tomont MLDSA_NAMESPACE(poly_invntt_tomont)
+void poly_invntt_tomont(poly *a);
+#define poly_pointwise_montgomery MLDSA_NAMESPACE(poly_pointwise_montgomery)
+void poly_pointwise_montgomery(poly *c, const poly *a, const poly *b);
+#define poly_pointwise_acc_montgomery MLDSA_NAMESPACE(poly_pointwise_acc_montgomery)
+void poly_pointwise_acc_montgomery(poly *c, const poly *a, const poly *b);
+
+#define poly_power2round MLDSA_NAMESPACE(poly_power2round)
+void poly_power2round(poly *a1, poly *a0, const poly *a);
+#define poly_decompose MLDSA_NAMESPACE(poly_decompose)
+void poly_decompose(poly *a1, poly *a0, const poly *a);
+#define poly_make_hint MLDSA_NAMESPACE(poly_make_hint)
+unsigned int poly_make_hint(poly *h, const poly *a0, const poly *a1);
+#define poly_use_hint MLDSA_NAMESPACE(poly_use_hint)
+void poly_use_hint(poly *b, const poly *a, const poly *h);
+
+#define poly_chknorm MLDSA_NAMESPACE(poly_chknorm)
+int poly_chknorm(const poly *a, int32_t B);
+#define poly_uniform MLDSA_NAMESPACE(poly_uniform)
+void poly_uniform(poly *a,
+                  const uint8_t seed[SEEDBYTES],
+                  uint16_t nonce);
+#define poly_uniform_eta MLDSA_NAMESPACE(poly_uniform_eta)
+void poly_uniform_eta(poly *a,
+                      const uint8_t seed[SEEDBYTES],
+                      uint16_t nonce);
+#define poly_uniform_gamma1 MLDSA_NAMESPACE(poly_uniform_gamma1)
+void poly_uniform_gamma1(poly *a,
+                         const uint8_t seed[TRBYTES],
+                         uint16_t nonce);
+#define poly_challenge MLDSA_NAMESPACE(poly_challenge)
+void poly_challenge(poly *c, const uint8_t seed[SEEDBYTES]);
+
+#define polyeta_pack MLDSA_NAMESPACE(polyeta_pack)
+void polyeta_pack(uint8_t *r, const poly *a);
+#define polyeta_unpack MLDSA_NAMESPACE(polyeta_unpack)
+void polyeta_unpack(poly *r, const uint8_t *a);
+
+#define polyt1_pack MLDSA_NAMESPACE(polyt1_pack)
+void polyt1_pack(uint8_t *r, const poly *a);
+#define polyt1_unpack MLDSA_NAMESPACE(polyt1_unpack)
+void polyt1_unpack(poly *r, const uint8_t *a);
+
+#define polyt0_pack MLDSA_NAMESPACE(polyt0_pack)
+void polyt0_pack(uint8_t *r, const poly *a);
+#define polyt0_unpack MLDSA_NAMESPACE(polyt0_unpack)
+void polyt0_unpack(poly *r, const uint8_t *a);
+
+#define polyz_pack MLDSA_NAMESPACE(polyz_pack)
+void polyz_pack(uint8_t *r, const poly *a);
+#define polyz_unpack MLDSA_NAMESPACE(polyz_unpack)
+void polyz_unpack(poly *r, const uint8_t *a);
+
+#define polyw1_pack MLDSA_NAMESPACE(polyw1_pack)
+void polyw1_pack(uint8_t *r, const poly *a);
+
+#endif
diff --git a/src/dilithium/polyvec.c b/src/ml-dsa/polyvec.c
similarity index 99%
rename from src/dilithium/polyvec.c
rename to src/ml-dsa/polyvec.c
index e6d900e..6d73794 100644
--- a/src/dilithium/polyvec.c
+++ b/src/ml-dsa/polyvec.c
@@ -40,7 +40,7 @@ void polyvecl_uniform_eta(polyvecl *v, const uint8_t seed[SEEDBYTES], uint16_t n
     poly_uniform_eta(&v->vec[i], seed, nonce++);
 }
 
-void polyvecl_uniform_gamma1(polyvecl *v, const uint8_t seed[CRHBYTES], uint16_t nonce) {
+void polyvecl_uniform_gamma1(polyvecl *v, const uint8_t seed[TRBYTES], uint16_t nonce) {
   unsigned int i;
 
   for(i = 0; i < L; ++i)
diff --git a/src/dilithium/polyvec.h b/src/ml-dsa/polyvec.h
similarity index 51%
rename from src/dilithium/polyvec.h
rename to src/ml-dsa/polyvec.h
index e294ba7..9103339 100644
--- a/src/dilithium/polyvec.h
+++ b/src/ml-dsa/polyvec.h
@@ -10,35 +10,35 @@ typedef struct {
   poly vec[L];
 } polyvecl;
 
-#define polyvecl_uniform_eta DILITHIUM_NAMESPACE(polyvecl_uniform_eta)
+#define polyvecl_uniform_eta MLDSA_NAMESPACE(polyvecl_uniform_eta)
 void polyvecl_uniform_eta(polyvecl *v, const uint8_t seed[SEEDBYTES], uint16_t nonce);
 
-#define polyvecl_uniform_gamma1 DILITHIUM_NAMESPACE(polyvecl_uniform_gamma1)
-void polyvecl_uniform_gamma1(polyvecl *v, const uint8_t seed[CRHBYTES], uint16_t nonce);
+#define polyvecl_uniform_gamma1 MLDSA_NAMESPACE(polyvecl_uniform_gamma1)
+void polyvecl_uniform_gamma1(polyvecl *v, const uint8_t seed[TRBYTES], uint16_t nonce);
 
-#define polyvecl_reduce DILITHIUM_NAMESPACE(polyvecl_reduce)
+#define polyvecl_reduce MLDSA_NAMESPACE(polyvecl_reduce)
 void polyvecl_reduce(polyvecl *v);
 
-#define polyvecl_freeze DILITHIUM_NAMESPACE(polyvecl_freeze)
+#define polyvecl_freeze MLDSA_NAMESPACE(polyvecl_freeze)
 void polyvecl_freeze(polyvecl *v);
 
-#define polyvecl_add DILITHIUM_NAMESPACE(polyvecl_add)
+#define polyvecl_add MLDSA_NAMESPACE(polyvecl_add)
 void polyvecl_add(polyvecl *w, const polyvecl *u, const polyvecl *v);
 
-#define polyvecl_ntt DILITHIUM_NAMESPACE(polyvecl_ntt)
+#define polyvecl_ntt MLDSA_NAMESPACE(polyvecl_ntt)
 void polyvecl_ntt(polyvecl *v);
-#define polyvecl_invntt_tomont DILITHIUM_NAMESPACE(polyvecl_invntt_tomont)
+#define polyvecl_invntt_tomont MLDSA_NAMESPACE(polyvecl_invntt_tomont)
 void polyvecl_invntt_tomont(polyvecl *v);
-#define polyvecl_pointwise_poly_montgomery DILITHIUM_NAMESPACE(polyvecl_pointwise_poly_montgomery)
+#define polyvecl_pointwise_poly_montgomery MLDSA_NAMESPACE(polyvecl_pointwise_poly_montgomery)
 void polyvecl_pointwise_poly_montgomery(polyvecl *r, const poly *a, const polyvecl *v);
 #define polyvecl_pointwise_acc_montgomery \
-        DILITHIUM_NAMESPACE(polyvecl_pointwise_acc_montgomery)
+        MLDSA_NAMESPACE(polyvecl_pointwise_acc_montgomery)
 void polyvecl_pointwise_acc_montgomery(poly *w,
                                        const polyvecl *u,
                                        const polyvecl *v);
 
 
-#define polyvecl_chknorm DILITHIUM_NAMESPACE(polyvecl_chknorm)
+#define polyvecl_chknorm MLDSA_NAMESPACE(polyvecl_chknorm)
 int polyvecl_chknorm(const polyvecl *v, int32_t B);
 
 
@@ -48,51 +48,51 @@ typedef struct {
   poly vec[K];
 } polyveck;
 
-#define polyveck_uniform_eta DILITHIUM_NAMESPACE(polyveck_uniform_eta)
+#define polyveck_uniform_eta MLDSA_NAMESPACE(polyveck_uniform_eta)
 void polyveck_uniform_eta(polyveck *v, const uint8_t seed[SEEDBYTES], uint16_t nonce);
 
-#define polyveck_reduce DILITHIUM_NAMESPACE(polyveck_reduce)
+#define polyveck_reduce MLDSA_NAMESPACE(polyveck_reduce)
 void polyveck_reduce(polyveck *v);
-#define polyveck_caddq DILITHIUM_NAMESPACE(polyveck_caddq)
+#define polyveck_caddq MLDSA_NAMESPACE(polyveck_caddq)
 void polyveck_caddq(polyveck *v);
-#define polyveck_freeze DILITHIUM_NAMESPACE(polyveck_freeze)
+#define polyveck_freeze MLDSA_NAMESPACE(polyveck_freeze)
 void polyveck_freeze(polyveck *v);
 
-#define polyveck_add DILITHIUM_NAMESPACE(polyveck_add)
+#define polyveck_add MLDSA_NAMESPACE(polyveck_add)
 void polyveck_add(polyveck *w, const polyveck *u, const polyveck *v);
-#define polyveck_sub DILITHIUM_NAMESPACE(polyveck_sub)
+#define polyveck_sub MLDSA_NAMESPACE(polyveck_sub)
 void polyveck_sub(polyveck *w, const polyveck *u, const polyveck *v);
-#define polyveck_shiftl DILITHIUM_NAMESPACE(polyveck_shiftl)
+#define polyveck_shiftl MLDSA_NAMESPACE(polyveck_shiftl)
 void polyveck_shiftl(polyveck *v);
 
-#define polyveck_ntt DILITHIUM_NAMESPACE(polyveck_ntt)
+#define polyveck_ntt MLDSA_NAMESPACE(polyveck_ntt)
 void polyveck_ntt(polyveck *v);
-#define polyveck_invntt_tomont DILITHIUM_NAMESPACE(polyveck_invntt_tomont)
+#define polyveck_invntt_tomont MLDSA_NAMESPACE(polyveck_invntt_tomont)
 void polyveck_invntt_tomont(polyveck *v);
-#define polyveck_pointwise_poly_montgomery DILITHIUM_NAMESPACE(polyveck_pointwise_poly_montgomery)
+#define polyveck_pointwise_poly_montgomery MLDSA_NAMESPACE(polyveck_pointwise_poly_montgomery)
 void polyveck_pointwise_poly_montgomery(polyveck *r, const poly *a, const polyveck *v);
 
-#define polyveck_chknorm DILITHIUM_NAMESPACE(polyveck_chknorm)
+#define polyveck_chknorm MLDSA_NAMESPACE(polyveck_chknorm)
 int polyveck_chknorm(const polyveck *v, int32_t B);
 
-#define polyveck_power2round DILITHIUM_NAMESPACE(polyveck_power2round)
+#define polyveck_power2round MLDSA_NAMESPACE(polyveck_power2round)
 void polyveck_power2round(polyveck *v1, polyveck *v0, const polyveck *v);
-#define polyveck_decompose DILITHIUM_NAMESPACE(polyveck_decompose)
+#define polyveck_decompose MLDSA_NAMESPACE(polyveck_decompose)
 void polyveck_decompose(polyveck *v1, polyveck *v0, const polyveck *v);
-#define polyveck_make_hint DILITHIUM_NAMESPACE(polyveck_make_hint)
+#define polyveck_make_hint MLDSA_NAMESPACE(polyveck_make_hint)
 unsigned int polyveck_make_hint(polyveck *h,
                                 const polyveck *v0,
                                 const polyveck *v1);
-#define polyveck_use_hint DILITHIUM_NAMESPACE(polyveck_use_hint)
+#define polyveck_use_hint MLDSA_NAMESPACE(polyveck_use_hint)
 void polyveck_use_hint(polyveck *w, const polyveck *v, const polyveck *h);
 
-#define polyveck_pack_w1 DILITHIUM_NAMESPACE(polyveck_pack_w1)
+#define polyveck_pack_w1 MLDSA_NAMESPACE(polyveck_pack_w1)
 void polyveck_pack_w1(uint8_t r[K*POLYW1_PACKEDBYTES], const polyveck *w1);
 
-#define polyvec_matrix_expand DILITHIUM_NAMESPACE(polyvec_matrix_expand)
+#define polyvec_matrix_expand MLDSA_NAMESPACE(polyvec_matrix_expand)
 void polyvec_matrix_expand(polyvecl mat[K], const uint8_t rho[SEEDBYTES]);
 
-#define polyvec_matrix_pointwise_montgomery DILITHIUM_NAMESPACE(polyvec_matrix_pointwise_montgomery)
+#define polyvec_matrix_pointwise_montgomery MLDSA_NAMESPACE(polyvec_matrix_pointwise_montgomery)
 void polyvec_matrix_pointwise_montgomery(polyveck *t, const polyvecl mat[K], const polyvecl *v);
 
 #endif
diff --git a/src/dilithium/reduce.h b/src/ml-dsa/reduce.h
similarity index 90%
rename from src/dilithium/reduce.h
rename to src/ml-dsa/reduce.h
index 02df550..46bb385 100644
--- a/src/dilithium/reduce.h
+++ b/src/ml-dsa/reduce.h
@@ -7,7 +7,7 @@
 #define MONT -4186625 // 2^32 % Q
 #define QINV 58728449 // q^(-1) mod 2^32
 
-#define montgomery_reduce DILITHIUM_NAMESPACE(montgomery_reduce)
+#define montgomery_reduce MLDSA_NAMESPACE(montgomery_reduce)
 /*************************************************
 * Name:        montgomery_reduce
 *
diff --git a/src/dilithium/rounding.c b/src/ml-dsa/rounding.c
similarity index 100%
rename from src/dilithium/rounding.c
rename to src/ml-dsa/rounding.c
diff --git a/src/dilithium/rounding.h b/src/ml-dsa/rounding.h
similarity index 58%
rename from src/dilithium/rounding.h
rename to src/ml-dsa/rounding.h
index b72e8e8..42fe4d1 100644
--- a/src/dilithium/rounding.h
+++ b/src/ml-dsa/rounding.h
@@ -4,16 +4,16 @@
 #include <stdint.h>
 #include "params.h"
 
-#define power2round DILITHIUM_NAMESPACE(power2round)
+#define power2round MLDSA_NAMESPACE(power2round)
 int32_t power2round(int32_t *a0, int32_t a);
 
-#define decompose DILITHIUM_NAMESPACE(decompose)
+#define decompose MLDSA_NAMESPACE(decompose)
 int32_t decompose(int32_t *a0, int32_t a);
 
-#define make_hint DILITHIUM_NAMESPACE(make_hint)
+#define make_hint MLDSA_NAMESPACE(make_hint)
 unsigned int make_hint(int32_t a0, int32_t a1);
 
-#define use_hint DILITHIUM_NAMESPACE(use_hint)
+#define use_hint MLDSA_NAMESPACE(use_hint)
 int32_t use_hint(int32_t a, unsigned int hint);
 
 #endif
diff --git a/src/dilithium/sign.c b/src/ml-dsa/sign.c
similarity index 99%
rename from src/dilithium/sign.c
rename to src/ml-dsa/sign.c
index 7482654..4f4c7b6 100644
--- a/src/dilithium/sign.c
+++ b/src/ml-dsa/sign.c
@@ -106,7 +106,7 @@ int crypto_sign_signature(uint8_t *sig,
   shake256_inc_finalize(&state);
   shake256_inc_squeeze(mu, CRHBYTES, &state);
 
-#ifdef DILITHIUM_RANDOMIZED_SIGNING
+#ifdef MLDSA_RANDOMIZED_SIGNING
   randombytes(rhoprime, CRHBYTES);
 #else
   crh(rhoprime, key, SEEDBYTES + CRHBYTES);
diff --git a/src/dilithium/sign.h b/src/ml-dsa/sign.h
similarity index 96%
rename from src/dilithium/sign.h
rename to src/ml-dsa/sign.h
index 42240b3..6d527f2 100644
--- a/src/dilithium/sign.h
+++ b/src/ml-dsa/sign.h
@@ -8,7 +8,7 @@
 #include "polyvec.h"
 #include "poly.h"
 
-#define challenge DILITHIUM_NAMESPACE(challenge)
+#define challenge MLDSA_NAMESPACE(challenge)
 void challenge(poly *c, const uint8_t seed[SEEDBYTES]);
 
 // #define crypto_sign_keypair DILITHIUM_NAMESPACE(crypto_sign_keypair)
diff --git a/src/dilithium/smallntt.S b/src/ml-dsa/smallntt.S
similarity index 100%
rename from src/dilithium/smallntt.S
rename to src/ml-dsa/smallntt.S
diff --git a/src/dilithium/smallntt.h b/src/ml-dsa/smallntt.h
similarity index 100%
rename from src/dilithium/smallntt.h
rename to src/ml-dsa/smallntt.h
diff --git a/src/dilithium/smallpoly.c b/src/ml-dsa/smallpoly.c
similarity index 100%
rename from src/dilithium/smallpoly.c
rename to src/ml-dsa/smallpoly.c
diff --git a/src/dilithium/smallpoly.h b/src/ml-dsa/smallpoly.h
similarity index 95%
rename from src/dilithium/smallpoly.h
rename to src/ml-dsa/smallpoly.h
index caa2626..bb82efb 100644
--- a/src/dilithium/smallpoly.h
+++ b/src/ml-dsa/smallpoly.h
@@ -6,7 +6,7 @@
 
 
 
-#if DILITHIUM_MODE == 3 // use q=769
+#if MLDSA_MODE == 65 // use q=769
 #define SMALL_POLY_16_BIT
 typedef struct {
     int16_t coeffs[N];
@@ -36,4 +36,4 @@ void poly_small_basemul_invntt(poly *r, const smallpoly *a, const smallhalfpoly
 
 void small_polyeta_unpack(smallpoly *r, const uint8_t *a);
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/dilithium/symmetric-shake.c b/src/ml-dsa/symmetric-shake.c
similarity index 69%
rename from src/dilithium/symmetric-shake.c
rename to src/ml-dsa/symmetric-shake.c
index 963f649..43226de 100644
--- a/src/dilithium/symmetric-shake.c
+++ b/src/ml-dsa/symmetric-shake.c
@@ -3,7 +3,7 @@
 #include "symmetric.h"
 #include "fips202.h"
 
-void dilithium_shake128_stream_init(shake128incctx *state, const uint8_t seed[SEEDBYTES], uint16_t nonce)
+void mldsa_shake128_stream_init(shake128incctx *state, const uint8_t seed[SEEDBYTES], uint16_t nonce)
 {
   uint8_t t[2];
   t[0] = nonce;
@@ -15,7 +15,7 @@ void dilithium_shake128_stream_init(shake128incctx *state, const uint8_t seed[SE
   shake128_inc_finalize(state);
 }
 
-void dilithium_shake256_stream_init(shake256incctx *state, const uint8_t seed[CRHBYTES], uint16_t nonce)
+void mldsa_shake256_stream_init(shake256incctx *state, const uint8_t seed[CRHBYTES], uint16_t nonce)
 {
   uint8_t t[2];
   t[0] = nonce;
diff --git a/src/dilithium/symmetric.h b/src/ml-dsa/symmetric.h
similarity index 72%
rename from src/dilithium/symmetric.h
rename to src/ml-dsa/symmetric.h
index 297c745..ec0104b 100644
--- a/src/dilithium/symmetric.h
+++ b/src/ml-dsa/symmetric.h
@@ -4,7 +4,7 @@
 #include <stdint.h>
 #include "params.h"
 
-#ifdef DILITHIUM_USE_AES
+#ifdef MLDSA_USE_AES
 
 #include "aes256ctr.h"
 #include "fips202.h"
@@ -12,8 +12,8 @@
 typedef aes256ctr_ctx stream128_state;
 typedef aes256ctr_ctx stream256_state;
 
-#define dilithium_aes256ctr_init DILITHIUM_NAMESPACE(dilithium_aes256ctr_init)
-void dilithium_aes256ctr_init(aes256ctr_ctx *state,
+#define mldsa_aes256ctr_init MLDSA_NAMESPACE(mldsa_aes256ctr_init)
+void mldsa_aes256ctr_init(aes256ctr_ctx *state,
                               const uint8_t key[32],
                               uint16_t nonce);
 
@@ -22,11 +22,11 @@ void dilithium_aes256ctr_init(aes256ctr_ctx *state,
 
 #define crh(OUT, IN, INBYTES) shake256(OUT, CRHBYTES, IN, INBYTES)
 #define stream128_init(STATE, SEED, NONCE) \
-        dilithium_aes256ctr_init(STATE, SEED, NONCE)
+        mldsa_aes256ctr_init(STATE, SEED, NONCE)
 #define stream128_squeezeblocks(OUT, OUTBLOCKS, STATE) \
         aes256ctr_squeezeblocks(OUT, OUTBLOCKS, STATE)
 #define stream256_init(STATE, SEED, NONCE) \
-        dilithium_aes256ctr_init(STATE, SEED, NONCE)
+        mldsa_aes256ctr_init(STATE, SEED, NONCE)
 #define stream256_squeezeblocks(OUT, OUTBLOCKS, STATE) \
         aes256ctr_squeezeblocks(OUT, OUTBLOCKS, STATE)
 
@@ -39,13 +39,13 @@ typedef shake256incctx stream256_state;
 #define shake256_inc_squeezeblocks(OUT, OUTBLOCKS, STATE) \
         shake256_inc_squeeze(OUT, OUTBLOCKS*SHAKE256_RATE, STATE)
 
-#define dilithium_shake128_stream_init DILITHIUM_NAMESPACE(dilithium_shake128_stream_init)
-void dilithium_shake128_stream_init(stream128_state *state,
+#define mldsa_shake128_stream_init MLDSA_NAMESPACE(mldsa_shake128_stream_init)
+void mldsa_shake128_stream_init(stream128_state *state,
                                     const uint8_t seed[SEEDBYTES],
                                     uint16_t nonce);
 
-#define dilithium_shake256_stream_init DILITHIUM_NAMESPACE(dilithium_shake256_stream_init)
-void dilithium_shake256_stream_init(stream256_state *state,
+#define mldsa_shake256_stream_init MLDSA_NAMESPACE(mldsa_shake256_stream_init)
+void mldsa_shake256_stream_init(stream256_state *state,
                                     const uint8_t seed[CRHBYTES],
                                     uint16_t nonce);
 
@@ -54,11 +54,11 @@ void dilithium_shake256_stream_init(stream256_state *state,
 
 #define crh(OUT, IN, INBYTES) shake256(OUT, CRHBYTES, IN, INBYTES)
 #define stream128_init(STATE, SEED, NONCE) \
-        dilithium_shake128_stream_init(STATE, SEED, NONCE)
+        mldsa_shake128_stream_init(STATE, SEED, NONCE)
 #define stream128_squeezeblocks(OUT, OUTBLOCKS, STATE) \
         shake128_inc_squeeze(OUT, OUTBLOCKS*SHAKE128_RATE, STATE)
 #define stream256_init(STATE, SEED, NONCE) \
-        dilithium_shake256_stream_init(STATE, SEED, NONCE)
+        mldsa_shake256_stream_init(STATE, SEED, NONCE)
 #define stream256_squeezeblocks(OUT, OUTBLOCKS, STATE) \
         shake256_inc_squeeze(OUT, OUTBLOCKS*SHAKE256_RATE, STATE)
 
diff --git a/src/dilithium/vector.h b/src/ml-dsa/vector.h
similarity index 62%
rename from src/dilithium/vector.h
rename to src/ml-dsa/vector.h
index 233c6a0..505d504 100644
--- a/src/dilithium/vector.h
+++ b/src/ml-dsa/vector.h
@@ -4,13 +4,13 @@
 #include <stdint.h>
 #include "params.h"
 
-#define asm_reduce32 DILITHIUM_NAMESPACE(asm_reduce32)
+#define asm_reduce32 MLDSA_NAMESPACE(asm_reduce32)
 void asm_reduce32(int32_t a[N]);
-#define asm_caddq DILITHIUM_NAMESPACE(asm_caddq)
+#define asm_caddq MLDSA_NAMESPACE(asm_caddq)
 void asm_caddq(int32_t a[N]);
-#define asm_freeze DILITHIUM_NAMESPACE(asm_freeze)
+#define asm_freeze MLDSA_NAMESPACE(asm_freeze)
 void asm_freeze(int32_t a[N]);
-#define asm_rej_uniform DILITHIUM_NAMESPACE(asm_rej_uniform)
+#define asm_rej_uniform MLDSA_NAMESPACE(asm_rej_uniform)
 unsigned int asm_rej_uniform(int32_t *a,
                          unsigned int len,
                          const unsigned char *buf,
diff --git a/src/dilithium/vector.s b/src/ml-dsa/vector.s
similarity index 81%
rename from src/dilithium/vector.s
rename to src/ml-dsa/vector.s
index d3eb720..4c3b9e5 100644
--- a/src/dilithium/vector.s
+++ b/src/ml-dsa/vector.s
@@ -7,10 +7,10 @@
 .endm
 
 // void asm_reduce32(int32_t a[N]);
-.global pqcrystals_dilithium_asm_reduce32
-.type pqcrystals_dilithium_asm_reduce32, %function
+.global pqcrystals_mldsa_asm_reduce32
+.type pqcrystals_mldsa_asm_reduce32, %function
 .align 2
-pqcrystals_dilithium_asm_reduce32:
+pqcrystals_mldsa_asm_reduce32:
     push {r4-r10}
 
     movw r12,#:lower16:8380417
@@ -48,7 +48,7 @@ pqcrystals_dilithium_asm_reduce32:
 
     pop {r4-r10}
     bx lr
-.size pqcrystals_dilithium_asm_reduce32, .-pqcrystals_dilithium_asm_reduce32
+.size pqcrystals_mldsa_asm_reduce32, .-pqcrystals_mldsa_asm_reduce32
 
 .macro caddq a, tmp, q
     and     \tmp, \q, \a, asr #31
@@ -61,10 +61,10 @@ pqcrystals_dilithium_asm_reduce32:
 .endm
 
 // // void asm_freeze(int32_t a[N]);
-// .global pqcrystals_dilithium_asm_freeze
-// .type pqcrystals_dilithium_asm_freeze, %function
+// .global pqcrystals_mldsa_asm_freeze
+// .type pqcrystals_mldsa_asm_freeze, %function
 // .align 2
-// pqcrystals_dilithium_asm_freeze:
+// pqcrystals_mldsa_asm_freeze:
 //     push {r4-r10}
 
 //     movw r12,#:lower16:8380417
@@ -103,13 +103,13 @@ pqcrystals_dilithium_asm_reduce32:
 
 //     pop {r4-r10}
 //     bx lr
-// .size pqcrystals_dilithium_asm_freeze, .-pqcrystals_dilithium_asm_freeze
+// .size pqcrystals_mldsa_asm_freeze, .-pqcrystals_mldsa_asm_freeze
 
 // void asm_caddq(int32_t a[N]);
-.global pqcrystals_dilithium_asm_caddq
-.type pqcrystals_dilithium_asm_caddq, %function
+.global pqcrystals_mldsa_asm_caddq
+.type pqcrystals_mldsa_asm_caddq, %function
 .align 2
-pqcrystals_dilithium_asm_caddq:
+pqcrystals_mldsa_asm_caddq:
     push {r4-r10}
 
     movw r12,#:lower16:8380417
@@ -148,14 +148,14 @@ pqcrystals_dilithium_asm_caddq:
 
     pop {r4-r10}
     bx lr
-.size pqcrystals_dilithium_asm_caddq, .-pqcrystals_dilithium_asm_caddq
+.size pqcrystals_mldsa_asm_caddq, .-pqcrystals_mldsa_asm_caddq
 
 
 // asm_rej_uniform(int32_t *a,unsigned int len,const unsigned char *buf, unsigned int buflen);
-.global pqcrystals_dilithium_asm_rej_uniform
-.type pqcrystals_dilithium_asm_rej_uniform, %function
+.global pqcrystals_mldsa_asm_rej_uniform
+.type pqcrystals_mldsa_asm_rej_uniform, %function
 .align 2
-pqcrystals_dilithium_asm_rej_uniform:
+pqcrystals_mldsa_asm_rej_uniform:
     push.w {r4-r6}
     push.w {r1}
     // Store Q-1 in r12.
@@ -188,4 +188,4 @@ end:
     sub.w r0, r5, r0, lsr #2
     pop.w {r4-r6}
     bx lr
-.size pqcrystals_dilithium_asm_rej_uniform, .-pqcrystals_dilithium_asm_rej_uniform
+.size pqcrystals_mldsa_asm_rej_uniform, .-pqcrystals_mldsa_asm_rej_uniform
diff --git a/src/ml-dsa/wrapper.c b/src/ml-dsa/wrapper.c
new file mode 100755
index 0000000..65d2549
--- /dev/null
+++ b/src/ml-dsa/wrapper.c
@@ -0,0 +1,51 @@
+#include "./wrapper.h"
+#include "./params.h"
+#include "./api.h"
+#include "./sign.h"
+#include "./poly.h"
+#include <string.h>
+
+#if MLDSA_PUBLIC_KEY_SIZE != CRYPTO_PUBLICKEYBYTES
+#error invalid public key size, update me!
+#endif
+#if MLDSA_PRIVATE_KEY_SIZE != CRYPTO_SECRETKEYBYTES
+#error invalid private key size, update me!
+#endif
+#if MLDSA_SIGNATURE_SIZE != CRYPTO_BYTES
+#error invalid signature size, update me! 
+#endif
+#if MLDSA_N != N
+#error invalid N, update me!
+#endif
+
+int getMldsaAlgorithmVariant() {
+	return MLDSA_MODE;
+}
+
+uint8_t* MldsaState_getPrivateKey(MldsaState* self) {
+	return self->m_sk;
+}
+
+uint8_t* MldsaState_getPublicKey(MldsaState* self) {
+	return self->m_pk;
+}
+
+uint8_t* MldsaState_getScratchPad(MldsaState* self) {
+	return self->m_scratchpad;
+}
+
+int MldsaState_verify(const MldsaState* self, uint8_t *signedMessage) {
+	size_t messageLength = MLDSA_MESSAGE_SIZE;
+	return crypto_sign_open(signedMessage, &messageLength, signedMessage, MLDSA_SIGNED_MESSAGE_SIZE, self->m_pk);
+}
+
+int MldsaState_sign(const MldsaState* self, uint8_t* signature, const uint8_t* message) {
+	size_t signatureSize = MLDSA_SIGNATURE_SIZE;
+	return crypto_sign_signature(signature, &signatureSize, message, MLDSA_MESSAGE_SIZE, self->m_sk);
+}
+
+int Mldsa_ntt(uint32_t* coefficients) {
+	poly* coeffs = (poly*)coefficients;
+	poly_ntt(coeffs);
+	return 0;
+}
diff --git a/src/ml-dsa/wrapper.h b/src/ml-dsa/wrapper.h
new file mode 100755
index 0000000..f9d2afb
--- /dev/null
+++ b/src/ml-dsa/wrapper.h
@@ -0,0 +1,93 @@
+#ifndef _MLDSA_WRAPPER_H_
+#define _MLDSA_WRAPPER_H_
+
+#include <stdint.h>
+#include <stddef.h>
+
+#define MLDSA_PUBLIC_KEY_SIZE 1952
+#define MLDSA_PRIVATE_KEY_SIZE 4032
+#define MLDSA_SIGNATURE_SIZE 3309
+#define MLDSA_MESSAGE_SIZE 16
+#define MLDSA_N 256
+#define MLDSA_SIGNED_MESSAGE_SIZE (MLDSA_SIGNATURE_SIZE + MLDSA_MESSAGE_SIZE)
+
+/**
+ * @brief      Get the MLDSA algorithm variant. There are a few variants and
+ *             only one of them is implemented.
+ *
+ * @return     The MLDSA algorithm variant.
+ */
+int getMldsaAlgorithmVariant();
+
+/**
+ * Simple object-oriented wrapper around the various Mldsa functions.
+ * All "methods" start with the prefix "MldsaState_".
+ */
+typedef struct MldsaState_t {
+	uint8_t m_pk[MLDSA_PUBLIC_KEY_SIZE];
+	uint8_t m_sk[MLDSA_PRIVATE_KEY_SIZE];
+    uint8_t m_scratchpad[MLDSA_SIGNED_MESSAGE_SIZE];
+} MldsaState;
+
+/**
+ * @brief      Get the private key bytes.
+ *
+ * @param[in]  self  The object
+ *
+ * @return     The private key bytes.
+ */
+uint8_t* MldsaState_getPrivateKey(MldsaState* self);
+
+/**
+ * @brief      Get the public key bytes.
+ *
+ * @param[in]  self  The object
+ *
+ * @return     The public key bytes.
+ */
+uint8_t* MldsaState_getPublicKey(MldsaState* self);
+
+/**
+ * @brief      Get the "scratch pad" for message storage, signature storage.
+ *
+ * @param      self  The object
+ *
+ * @return     Pointer to the scratch pad.
+ */
+uint8_t* MldsaState_getScratchPad(MldsaState* self);
+
+/**
+ * @brief      Verify a signed message.
+ *
+ * @param[in]  self           The object
+ * @param[in]  signature      Buffer of the signed message. This buffer MUST have
+ *                            length MLDSA_SIGNATURE_SIZE + MLDSA_MESSAGE_SIZE.
+ *
+ * @return     0 when verification passes, non-zero otherwise.
+ */
+int MldsaState_verify(const MldsaState* self, uint8_t *signedMessage);
+
+/**
+ * @brief      Sign a message.
+ *
+ * @param[in]  self           The object
+ * @param[out] signature      Buffer where the signature will be placed in. This
+ *                            buffer MUST have length MLDSA_SIGNATURE_SIZE.
+ * @param[in]  message        Buffer of the message to be signed. This buffer MUST
+ *                            have length MLDSA_MESSAGE_SIZE.
+ *
+ * @return     0 when signing succeeds, non-zero otherwise.
+ */
+int MldsaState_sign(const MldsaState* self, uint8_t* signature, const uint8_t* message);
+
+///
+/// @brief        Perform a forward NTT.
+///
+/// @param[inout] coefficients  Buffer of polynomial coefficients in integer
+///                             domain. The computation is done in-place, and
+///                             this array contains the coefficients in the
+///                             frequency domain after this function returns.
+///
+int Mldsa_ntt(uint32_t *coefficients);
+
+#endif // _MLDSA_WRAPPER_H_