As quantum computing advances, the cryptographic foundations of modern Java applications face unprecedented challenges. Dilithium, a lattice-based digital signature scheme, is one of the leading candidates selected by NIST for post-quantum cryptography standardization. For Java developers building long-lived systems—blockchain applications, secure messaging, digital certificates—integrating Dilithium ensures that signatures remain secure even against quantum adversaries.

What is Dilithium?

Dilithium is a digital signature algorithm based on the hardness of lattice problems, specifically Module Learning With Errors (MLWE). It was selected by NIST in 2022 as a primary algorithm for post-quantum digital signatures (along with Falcon). Dilithium offers:

• Strong security: Believed secure against both classical and quantum computers
• Efficient verification: Fast signature verification suitable for high-throughput systems
• Moderate signature sizes: Larger than ECDSA but smaller than many other post-quantum schemes
• Deterministic signing: No randomness required, preventing certain side-channel attacks

Why Dilithium is Critical for Future-Proof Java Applications

1. Quantum Threat Preparedness: RSA and ECDSA signatures will be broken by Shor's algorithm on sufficiently powerful quantum computers.
2. Long-Lived Data Protection: Documents, certificates, and signed data with long validity periods need quantum-resistant signatures today.
3. Regulatory Requirements: Some jurisdictions are beginning to mandate post-quantum readiness for government systems.
4. NIST Standardization: Dilithium is a NIST-selected algorithm, ensuring broad adoption and rigorous security analysis.
5. Forward Compatibility: Early adoption ensures systems can interoperate with future post-quantum infrastructure.

Dilithium Algorithm Variants

Dilithium comes in three security levels, offering different trade-offs between security, key size, and performance:

Implementing Dilithium in Java

1. Maven Dependencies

<dependencies>
<!-- Bouncy Castle with Dilithium support (experimental) -->
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk15on</artifactId>
<version>1.70</version>
</dependency>
<!-- PQClean Java wrapper for Dilithium -->
<dependency>
<groupId>org.pqclean</groupId>
<artifactId>pqclean-java</artifactId>
<version>1.0.0</version>
</dependency>
<!-- Native integration with Open Quantum Safe (optional, better performance) -->
<dependency>
<groupId>org.openquantumsafe</groupId>
<artifactId>oqs-java</artifactId>
<version>0.7.0</version>
</dependency>
</dependencies>

2. Basic Dilithium Operations with Bouncy Castle

import org.bouncycastle.pqc.jcajce.provider.BouncyCastlePQCProvider;
import org.bouncycastle.pqc.jcajce.spec.DilithiumParameterSpec;
import org.bouncycastle.pqc.jcajce.provider.dilithium.BCDilithiumPrivateKey;
import org.bouncycastle.pqc.jcajce.provider.dilithium.BCDilithiumPublicKey;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
public class DilithiumBasicExample {
static {
// Register Bouncy Castle provider
Security.addProvider(new BouncyCastlePQCProvider());
}
public static class DilithiumKeyPair {
private final PublicKey publicKey;
private final PrivateKey privateKey;
public DilithiumKeyPair(PublicKey publicKey, PrivateKey privateKey) {
this.publicKey = publicKey;
this.privateKey = privateKey;
}
public String getPublicKeyBase64() {
return Base64.getEncoder().encodeToString(publicKey.getEncoded());
}
public String getPrivateKeyBase64() {
return Base64.getEncoder().encodeToString(privateKey.getEncoded());
}
}
public static DilithiumKeyPair generateKeyPair(String variant) throws Exception {
// Get Dilithium algorithm instance
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("Dilithium");
// Configure parameters based on variant
DilithiumParameterSpec spec;
switch (variant) {
case "Dilithium2":
spec = DilithiumParameterSpec.dilithium2;
break;
case "Dilithium3":
spec = DilithiumParameterSpec.dilithium3;
break;
case "Dilithium5":
spec = DilithiumParameterSpec.dilithium5;
break;
default:
throw new IllegalArgumentException("Unknown Dilithium variant: " + variant);
}
// Initialize and generate keys
keyPairGenerator.initialize(spec, new SecureRandom());
KeyPair keyPair = keyPairGenerator.generateKeyPair();
return new DilithiumKeyPair(keyPair.getPublic(), keyPair.getPrivate());
}
public static byte[] signData(PrivateKey privateKey, byte[] data) throws Exception {
Signature signer = Signature.getInstance("Dilithium");
signer.initSign(privateKey);
signer.update(data);
return signer.sign();
}
public static boolean verifySignature(PublicKey publicKey, byte[] data, byte[] signature) throws Exception {
Signature verifier = Signature.getInstance("Dilithium");
verifier.initVerify(publicKey);
verifier.update(data);
return verifier.verify(signature);
}
public static void main(String[] args) {
try {
// Generate key pair
System.out.println("Generating Dilithium2 key pair...");
DilithiumKeyPair keyPair = generateKeyPair("Dilithium2");
System.out.println("Public Key Size: " + keyPair.publicKey.getEncoded().length + " bytes");
System.out.println("Private Key Size: " + keyPair.privateKey.getEncoded().length + " bytes");
// Sign data
String message = "This is a post-quantum signed message";
byte[] messageBytes = message.getBytes();
byte[] signature = signData(keyPair.privateKey, messageBytes);
System.out.println("Signature Size: " + signature.length + " bytes");
// Verify signature
boolean valid = verifySignature(keyPair.publicKey, messageBytes, signature);
System.out.println("Signature Valid: " + valid);
// Demonstrate tamper detection
messageBytes[0] = (byte) (messageBytes[0] ^ 0xFF); // Corrupt message
boolean tamperedValid = verifySignature(keyPair.publicKey, messageBytes, signature);
System.out.println("Tampered Message Valid: " + tamperedValid);
} catch (Exception e) {
e.printStackTrace();
}
}
}

3. Key Serialization and Storage

import java.io.*;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
public class DilithiumKeyStorage {
private static final String PROVIDER = "BCPQC";
public static void saveKeys(PublicKey publicKey, PrivateKey privateKey, 
String baseFilename) throws IOException {
// Save public key
try (FileOutputStream fos = new FileOutputStream(baseFilename + ".pub")) {
fos.write(publicKey.getEncoded());
}
// Save private key (encrypt in production!)
try (FileOutputStream fos = new FileOutputStream(baseFilename + ".priv")) {
fos.write(privateKey.getEncoded());
}
}
public static DilithiumKeyPair loadKeys(String baseFilename) throws Exception {
// Load public key
byte[] publicKeyBytes;
try (FileInputStream fis = new FileInputStream(baseFilename + ".pub")) {
publicKeyBytes = fis.readAllBytes();
}
// Load private key
byte[] privateKeyBytes;
try (FileInputStream fis = new FileInputStream(baseFilename + ".priv")) {
privateKeyBytes = fis.readAllBytes();
}
// Reconstruct keys
KeyFactory keyFactory = KeyFactory.getInstance("Dilithium", PROVIDER);
X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(publicKeyBytes);
PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);
PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
PrivateKey privateKey = keyFactory.generatePrivate(privateKeySpec);
return new DilithiumKeyPair(publicKey, privateKey);
}
// Securely delete keys when done
public static void secureDelete(String filename) throws IOException {
File file = new File(filename);
if (file.exists()) {
// Overwrite with random data multiple times
RandomAccessFile raf = new RandomAccessFile(file, "rws");
byte[] randomBytes = new byte[(int) file.length()];
for (int i = 0; i < 3; i++) {
new SecureRandom().nextBytes(randomBytes);
raf.seek(0);
raf.write(randomBytes);
}
raf.close();
file.delete();
}
}
}

4. High-Performance Implementation with Open Quantum Safe

import org.openquantumsafe.Signature;
import org.openquantumsafe.KeyPair;
import org.openquantumsafe.ops.SecurityLevel;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
public class OQSDilithiumExample {
public static class OQSDilithiumKeys {
private final byte[] publicKey;
private final byte[] privateKey;
private final String algorithm;
public OQSDilithiumKeys(byte[] publicKey, byte[] privateKey, String algorithm) {
this.publicKey = publicKey;
this.privateKey = privateKey;
this.algorithm = algorithm;
}
}
public static OQSDilithiumKeys generateKeys(String variant) {
// Initialize signature object
try (Signature signer = new Signature(variant)) {
// Generate key pair
KeyPair keyPair = signer.generate_keypair();
return new OQSDilithiumKeys(
keyPair.public_key,
keyPair.private_key,
variant
);
}
}
public static byte[] sign(byte[] message, byte[] privateKey, String algorithm) {
try (Signature signer = new Signature(algorithm)) {
// Load private key
signer.set_secret_key(privateKey);
// Generate signature
return signer.sign(message);
}
}
public static boolean verify(byte[] message, byte[] signature, 
byte[] publicKey, String algorithm) {
try (Signature verifier = new Signature(algorithm)) {
// Set public key
verifier.set_public_key(publicKey);
// Verify
return verifier.verify(message, signature);
}
}
public static void performanceTest() {
String[] variants = {"Dilithium2", "Dilithium3", "Dilithium5"};
byte[] testMessage = "Performance test message".getBytes(StandardCharsets.UTF_8);
for (String variant : variants) {
System.out.println("\nTesting " + variant + ":");
// Key generation timing
long start = System.nanoTime();
OQSDilithiumKeys keys = generateKeys(variant);
long keyGenTime = System.nanoTime() - start;
System.out.println("  Key Generation: " + (keyGenTime / 1_000_000) + " ms");
System.out.println("  Public Key Size: " + keys.publicKey.length + " bytes");
System.out.println("  Private Key Size: " + keys.privateKey.length + " bytes");
// Signing timing
start = System.nanoTime();
byte[] signature = sign(testMessage, keys.privateKey, variant);
long signTime = System.nanoTime() - start;
System.out.println("  Signing: " + (signTime / 1_000_000) + " ms");
System.out.println("  Signature Size: " + signature.length + " bytes");
// Verification timing
start = System.nanoTime();
boolean valid = verify(testMessage, signature, keys.publicKey, variant);
long verifyTime = System.nanoTime() - start;
System.out.println("  Verification: " + (verifyTime / 1_000_000) + " ms");
System.out.println("  Valid: " + valid);
}
}
public static void main(String[] args) {
performanceTest();
}
}

Integration with Java Security Architecture

1. Custom JCE Provider Implementation

package com.example.pqc.jce;
import java.security.*;
import java.security.spec.AlgorithmParameterSpec;
import javax.crypto.ShortBufferException;
public final class DilithiumSignature extends SignatureSpi {
private byte[] privateKey;
private byte[] publicKey;
private byte[] messageBuffer;
private int mode;
private final String algorithm;
public DilithiumSignature(String algorithm) {
this.algorithm = algorithm;
}
@Override
protected void engineInitVerify(PublicKey publicKey) throws InvalidKeyException {
if (!(publicKey instanceof DilithiumPublicKey)) {
throw new InvalidKeyException("Unsupported key type");
}
this.publicKey = publicKey.getEncoded();
this.mode = MODE_VERIFY;
this.messageBuffer = new byte[0];
}
@Override
protected void engineInitSign(PrivateKey privateKey) throws InvalidKeyException {
if (!(privateKey instanceof DilithiumPrivateKey)) {
throw new InvalidKeyException("Unsupported key type");
}
this.privateKey = privateKey.getEncoded();
this.mode = MODE_SIGN;
this.messageBuffer = new byte[0];
}
@Override
protected void engineUpdate(byte b) throws SignatureException {
byte[] newBuffer = new byte[messageBuffer.length + 1];
System.arraycopy(messageBuffer, 0, newBuffer, 0, messageBuffer.length);
newBuffer[messageBuffer.length] = b;
messageBuffer = newBuffer;
}
@Override
protected void engineUpdate(byte[] b, int off, int len) throws SignatureException {
byte[] newBuffer = new byte[messageBuffer.length + len];
System.arraycopy(messageBuffer, 0, newBuffer, 0, messageBuffer.length);
System.arraycopy(b, off, newBuffer, messageBuffer.length, len);
messageBuffer = newBuffer;
}
@Override
protected byte[] engineSign() throws SignatureException {
if (mode != MODE_SIGN) {
throw new SignatureException("Not initialized for signing");
}
try (Signature signer = new Signature(algorithm)) {
signer.set_secret_key(privateKey);
return signer.sign(messageBuffer);
} catch (Exception e) {
throw new SignatureException("Signing failed", e);
}
}
@Override
protected boolean engineVerify(byte[] sigBytes) throws SignatureException {
if (mode != MODE_VERIFY) {
throw new SignatureException("Not initialized for verification");
}
try (Signature verifier = new Signature(algorithm)) {
verifier.set_public_key(publicKey);
return verifier.verify(messageBuffer, sigBytes);
} catch (Exception e) {
throw new SignatureException("Verification failed", e);
}
}
@Override
protected void engineSetParameter(String param, Object value) {
// Not supported
}
@Override
protected Object engineGetParameter(String param) {
return null;
}
}

2. X.509 Certificate Integration

import java.security.cert.*;
import java.math.BigInteger;
import java.util.Date;
import javax.security.auth.x500.X500Principal;
public class DilithiumCertificateGenerator {
public static X509Certificate generateSelfSignedCertificate(
PublicKey publicKey, PrivateKey privateKey, 
String dn, int days) throws Exception {
// Create certificate info
X500Principal subject = new X500Principal(dn);
Date notBefore = new Date();
Date notAfter = new Date(notBefore.getTime() + days * 86400000L);
BigInteger serial = new BigInteger(64, new SecureRandom());
// Create certificate builder
X509v3CertificateBuilder certBuilder = new JcaX509v3CertificateBuilder(
subject, serial, notBefore, notAfter, subject, publicKey);
// Add extensions
certBuilder.addExtension(
Extension.basicConstraints, true, new BasicConstraints(true));
certBuilder.addExtension(
Extension.keyUsage, true, 
new KeyUsage(KeyUsage.keyCertSign | KeyUsage.digitalSignature));
// Build and sign
ContentSigner signer = new JcaContentSignerBuilder("Dilithium")
.setProvider("BCPQC")
.build(privateKey);
X509CertificateHolder certHolder = certBuilder.build(signer);
// Convert to JCA certificate
CertificateFactory cf = CertificateFactory.getInstance("X.509");
return (X509Certificate) cf.generateCertificate(
new ByteArrayInputStream(certHolder.getEncoded()));
}
}

Real-World Use Cases

1. Blockchain Transaction Signing

public class BlockchainTransaction {
private final DilithiumService dilithiumService;
public BlockchainTransaction() {
this.dilithiumService = new DilithiumService("Dilithium5");
}
public SignedTransaction signTransaction(Transaction tx, String privateKeyBase64) {
// Create transaction hash
byte[] txHash = calculateTransactionHash(tx);
// Sign with Dilithium
byte[] signature = dilithiumService.sign(
txHash, 
Base64.getDecoder().decode(privateKeyBase64)
);
return new SignedTransaction(tx, signature);
}
public boolean verifyTransaction(SignedTransaction signedTx, String publicKeyBase64) {
byte[] txHash = calculateTransactionHash(signedTx.getTransaction());
byte[] publicKey = Base64.getDecoder().decode(publicKeyBase64);
byte[] signature = signedTx.getSignature();
return dilithiumService.verify(txHash, signature, publicKey);
}
private byte[] calculateTransactionHash(Transaction tx) {
try {
MessageDigest digest = MessageDigest.getInstance("SHA-256");
return digest.digest(tx.toString().getBytes());
} catch (NoSuchAlgorithmException e) {
throw new RuntimeException("SHA-256 not available", e);
}
}
}

2. Secure Messaging with Long-Term Signatures

public class SecureMessage {
private final byte[] content;
private final byte[] signature;
private final String signerId;
private final long timestamp;
public SecureMessage(String content, DilithiumKeyPair keys, String signerId) {
this.content = content.getBytes(StandardCharsets.UTF_8);
this.timestamp = System.currentTimeMillis();
this.signerId = signerId;
// Create signed message (content + timestamp)
byte[] dataToSign = createDataToSign();
this.signature = DilithiumOps.sign(dataToSign, keys.getPrivateKey());
}
private byte[] createDataToSign() {
byte[] contentBytes = content;
byte[] timestampBytes = Long.toString(timestamp).getBytes();
byte[] signerBytes = signerId.getBytes();
ByteBuffer buffer = ByteBuffer.allocate(
contentBytes.length + timestampBytes.length + signerBytes.length);
buffer.put(contentBytes);
buffer.put(timestampBytes);
buffer.put(signerBytes);
return buffer.array();
}
public boolean verify(DilithiumKeyPair keys) {
byte[] dataToVerify = createDataToSign();
return DilithiumOps.verify(dataToVerify, signature, keys.getPublicKey());
}
// For long-term archival, include algorithm info
public String getArchivalFormat() {
JSONObject archival = new JSONObject();
archival.put("algorithm", "Dilithium5");
archival.put("timestamp", timestamp);
archival.put("signer", signerId);
archival.put("content_base64", Base64.getEncoder().encodeToString(content));
archival.put("signature_base64", Base64.getEncoder().encodeToString(signature));
archival.put("public_key_algorithm", "Dilithium5");
return archival.toString(2);
}
}

3. Code Signing for Long-Lived Artifacts

public class DilithiumCodeSigner {
public static void signJar(File jarFile, DilithiumKeyPair keys) throws Exception {
// Create manifest
Manifest manifest = new Manifest();
Attributes main = manifest.getMainAttributes();
main.putValue("Manifest-Version", "1.0");
main.putValue("Created-By", "Dilithium Code Signer");
main.putValue("Signature-Algorithm", "Dilithium5");
main.putValue("X-Dilithium-Public-Key", 
Base64.getEncoder().encodeToString(keys.getPublicKey().getEncoded()));
// Hash each file
try (JarFile jar = new JarFile(jarFile);
JarOutputStream jos = new JarOutputStream(
new FileOutputStream("signed-" + jarFile.getName()))) {
Enumeration<JarEntry> entries = jar.entries();
while (entries.hasMoreElements()) {
JarEntry entry = entries.nextElement();
// Copy entry
jos.putNextEntry(new JarEntry(entry.getName()));
InputStream is = jar.getInputStream(entry);
byte[] buffer = new byte[4096];
int bytesRead;
while ((bytesRead = is.read(buffer)) != -1) {
jos.write(buffer, 0, bytesRead);
}
// Add to manifest
if (!entry.isDirectory() && !entry.getName().startsWith("META-INF")) {
manifest.getEntries().put(entry.getName(), new Attributes());
}
}
// Write manifest
jos.putNextEntry(new JarEntry("META-INF/MANIFEST.MF"));
manifest.write(jos);
// Write signature file
jos.putNextEntry(new JarEntry("META-INF/DILITHIUM.SF"));
SignatureFile sf = new SignatureFile(manifest, keys);
sf.write(jos);
// Write signature block
jos.putNextEntry(new JarEntry("META-INF/DILITHIUM.DIL"));
jos.write(sf.getSignatureBlock());
}
}
}

Performance Optimization

1. Batch Verification

public class DilithiumBatchVerifier {
private final String algorithm;
private final int batchSize;
private final List<VerificationTask> pending = new ArrayList<>();
public DilithiumBatchVerifier(String algorithm, int batchSize) {
this.algorithm = algorithm;
this.batchSize = batchSize;
}
public void addForVerification(byte[] message, byte[] signature, byte[] publicKey) {
pending.add(new VerificationTask(message, signature, publicKey));
if (pending.size() >= batchSize) {
verifyBatch();
}
}
public List<Boolean> verifyBatch() {
if (pending.isEmpty()) {
return Collections.emptyList();
}
List<Boolean> results = new ArrayList<>();
// Batch verification can be optimized in native implementations
try (Signature verifier = new Signature(algorithm)) {
for (VerificationTask task : pending) {
verifier.set_public_key(task.publicKey);
boolean valid = verifier.verify(task.message, task.signature);
results.add(valid);
}
}
pending.clear();
return results;
}
private static class VerificationTask {
final byte[] message;
final byte[] signature;
final byte[] publicKey;
VerificationTask(byte[] message, byte[] signature, byte[] publicKey) {
this.message = message.clone();
this.signature = signature.clone();
this.publicKey = publicKey.clone();
}
}
}

2. Caching Public Key Operations

@ThreadSafe
public class DilithiumVerificationCache {
private final LoadingCache<CacheKey, Boolean> cache;
public DilithiumVerificationCache(int maxSize, int expireAfterMinutes) {
this.cache = Caffeine.newBuilder()
.maximumSize(maxSize)
.expireAfterWrite(expireAfterMinutes, TimeUnit.MINUTES)
.recordStats()
.build(key -> verifyWithCache(key));
}
public boolean verify(byte[] message, byte[] signature, byte[] publicKey, String algorithm) {
CacheKey key = new CacheKey(message, signature, publicKey, algorithm);
return cache.get(key);
}
private boolean verifyWithCache(CacheKey key) {
try (Signature verifier = new Signature(key.algorithm)) {
verifier.set_public_key(key.publicKey);
return verifier.verify(key.message, key.signature);
}
}
@Value
private static class CacheKey {
byte[] message;
byte[] signature;
byte[] publicKey;
String algorithm;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof CacheKey)) return false;
CacheKey that = (CacheKey) o;
return Arrays.equals(message, that.message) &&
Arrays.equals(signature, that.signature) &&
Arrays.equals(publicKey, that.publicKey) &&
algorithm.equals(that.algorithm);
}
@Override
public int hashCode() {
int result = Arrays.hashCode(message);
result = 31 * result + Arrays.hashCode(signature);
result = 31 * result + Arrays.hashCode(publicKey);
result = 31 * result + algorithm.hashCode();
return result;
}
}
}

Security Best Practices

1. Use Appropriate Security Levels: Dilithium5 for highest security, Dilithium2 for balanced performance.
2. Secure Key Storage: Encrypt private keys at rest; use hardware security modules when possible.
3. Constant-Time Operations: Ensure implementations are constant-time to prevent timing attacks.
4. Randomness Quality: While Dilithium signing is deterministic, key generation requires high-quality randomness.
5. Key Rotation: Implement regular key rotation despite post-quantum security.
6. Hybrid Mode: Consider using Dilithium alongside classical signatures during transition period.

Hybrid Signatures (Classical + Quantum)

public class HybridSignature {
private final Signature ed25519Signer;
private final DilithiumService dilithiumService;
public HybridSignature() {
this.ed25519Signer = Signature.getInstance("Ed25519");
this.dilithiumService = new DilithiumService("Dilithium5");
}
public HybridSignatureData sign(byte[] data, 
PrivateKey ed25519Key, 
byte[] dilithiumPrivateKey) throws Exception {
// Sign with classical algorithm
ed25519Signer.initSign(ed25519Key);
ed25519Signer.update(data);
byte[] ed25519Signature = ed25519Signer.sign();
// Sign with post-quantum algorithm
byte[] dilithiumSignature = dilithiumService.sign(data, dilithiumPrivateKey);
return new HybridSignatureData(ed25519Signature, dilithiumSignature);
}
public boolean verify(byte[] data, HybridSignatureData signature,
PublicKey ed25519PublicKey, byte[] dilithiumPublicKey) 
throws Exception {
// Verify classical signature
ed25519Signer.initVerify(ed25519PublicKey);
ed25519Signer.update(data);
boolean ed25519Valid = ed25519Signer.verify(signature.getEd25519Signature());
// Verify post-quantum signature
boolean dilithiumValid = dilithiumService.verify(
data, signature.getDilithiumSignature(), dilithiumPublicKey);
// Both must be valid
return ed25519Valid && dilithiumValid;
}
}

Conclusion

Dilithium signatures represent the future of digital signatures in a post-quantum world. For Java developers building systems that must remain secure for years or decades, integrating Dilithium today is a critical step toward quantum readiness.

While Dilithium signatures are larger than classical alternatives, their security properties and NIST standardization make them the preferred choice for post-quantum signing. As hardware acceleration and optimized implementations mature, the performance gap will continue to narrow.

By adopting Dilithium in Java applications now, developers can ensure their systems remain secure through the quantum transition, protecting digital signatures, certificates, and authenticated communications for years to come.