Accessing spvBindlessTextureNV capability with the compiler API

[m-schuetz]

EDIT: Resolved

The issue was that I did not put the slang.dll from v2025.19 in the binary folder, and I guess the application instead used the older slang.dll from the Vulkan SDK. A reminder for me to uninstall the VulkanSDK.

Original Question:

Hi,

I'm trying to compile shaders with the spvBindlessTextureNV capability, and this actually works using slangc:

slangc shader.slang -target spirv -capability spvBindlessTextureNV -emit-spirv-directly -fvk-use-entrypoint-name -source-embed-style u32 -source-embed-name shader_spv -o shaders.h

However, I cannot get it to work with the compiler API, which always throws:

f9a17e4368cb3ac8cb036c3eee40bea98da8a70e(10): error 36105: unknown capability name 'spvBindlessTextureNV'.
[require(spvRayTracingKHR, spvRayQueryKHR, spvBindlessTextureNV)]
                                           ^~~~~~~~~~~~~~~~~~~~
(0): error 39999: import of module 'basicShader' failed because of a compilation error
(0): fatal error 39999: compilation ceased
abort compilation: (0): fatal error 39999: compilation ceased

In both cases I'm using v2025.19.

I guess I have to use a command-line equivalent of -capability spvBindlessTextureNV when using the compiler API, but I am a little lost on how to achieve this.

Things I tried:

With the deprecated API

SlangSession* session = spCreateSession(NULL);
SlangCompileRequest* request = spCreateCompileRequest(session);

int targetIndex = spAddCodeGenTarget(request, SLANG_SPIRV);

spSetTargetProfile(request, targetIndex, spFindProfile(session, "spirv_1_6"));
spAddTargetCapability(request, targetIndex, spFindCapability(session, "SPV_NV_bindless_texture"));
spAddTargetCapability(request, targetIndex, spFindCapability(session, "spvBindlessTextureNV"));

SlangCapabilityID cap0 = spFindCapability(session, "SPV_NV_bindless_texture");
SlangCapabilityID cap1 = spFindCapability(session, "spvBindlessTextureNV");
SlangCapabilityID cap2 = spFindCapability(session, "SpvCapabilityBindlessTextureNV");
SlangCapabilityID cap3 = spFindCapability(session, "BindlessTextureNV");
SlangCapabilityID cap4 = spFindCapability(session, "spvRayQueryKHR");

spAddTranslationUnit(request, SLANG_SOURCE_LANGUAGE_SLANG, "default");
spAddTranslationUnitSourceFile(request, 0, "./src/shaders/bindlesstest.slang");
// spAddTranslationUnitSourceString(request, 0, "shader.slang", shaderCode);

SlangResult res = spCompile(request);

if (SLANG_FAILED(res)) {
	const char* diagnostics = spGetDiagnosticOutput(request);
	fprintf(stderr, "Slang compile error:\n%s\n", diagnostics);
}

This gives me the unknown capability name error. cap0 to cap3 were attempts of finding the capability ID, but all of them return SLANG_CAPABILITY_UNKNOWN. For comparison, cap4 returns a valid number for a different capability.

With new API

ComPtr<IGlobalSession> globalSession;
createGlobalSession(globalSession.writeRef());

// create Session
SessionDesc sessionDesc = {};

TargetDesc targetDesc = {};
targetDesc.format = SLANG_SPIRV;
targetDesc.profile = globalSession->findProfile("spirv_1_6");

sessionDesc.targets = &targetDesc;
sessionDesc.targetCount = 1;

// preprocessor defines
vector<PreprocessorMacroDesc> preprocessorMacroDesc = {
	{ "BIAS_VALUE", "1138" },
	{ "OTHER_MACRO", "float" }
};
sessionDesc.preprocessorMacros = preprocessorMacroDesc.data();
sessionDesc.preprocessorMacroCount = preprocessorMacroDesc.size();

// compiler options
vector<CompilerOptionEntry> options = {
	{
		CompilerOptionName::EmitSpirvDirectly,
		{CompilerOptionValueKind::Int, 1, 0, nullptr, nullptr}
	},{
		CompilerOptionName::VulkanUseEntryPointName,
		{CompilerOptionValueKind::Int, 1, 0, nullptr, nullptr}
	},
	// {
	// 	CompilerOptionName::Capability,
	// 	{CompilerOptionValueKind::String, 0, 0, nullptr, "spvBindlessTextureNV"}
	// },
	// {
	// 	CompilerOptionName::Capability,
	// 	{CompilerOptionValueKind::String, 0, 0, nullptr, "SPV_NV_bindless_texture"}
	// },
	// {
	// 	CompilerOptionName::Capability,
	// 	{CompilerOptionValueKind::String, 0, 0, nullptr, "SpvCapabilityBindlessTextureNV"}
	// },
	// {
	// 	CompilerOptionName::Capability,
	// 	{CompilerOptionValueKind::String, 0, 0, nullptr, "BindlessTextureNV"}
	// },
	// {
	// 	CompilerOptionName::Capability,
	// 	{CompilerOptionValueKind::Int, 1, 0, nullptr, nullptr}
	// 	// {CompilerOptionValueKind::Int, 3782, 24, nullptr, nullptr}
	// },
};

sessionDesc.compilerOptionEntries = options.data();
sessionDesc.compilerOptionEntryCount = options.size();

SlangCapabilityID id1 = globalSession->findCapability("SPV_NV_bindless_texture");
SlangCapabilityID id2 = globalSession->findCapability("spvBindlessTextureNV");
SlangCapabilityID id3 = globalSession->findCapability("SpvCapabilityBindlessTextureNV");
SlangCapabilityID id4 = globalSession->findCapability("BindlessTextureNV");

ComPtr<ISession> session;
auto res = globalSession->createSession(sessionDesc, session.writeRef());
if(!SLANG_SUCCEEDED(res)){
	printf("error trying to create slang session");
	return nullptr;
}


// load modules
ComPtr<IBlob> diagnosticsBlob;
ComPtr<IModule> slangModule;
slangModule = session->loadModuleFromSourceString(moduleName.c_str(), nullptr, source.c_str(), diagnosticsBlob.writeRef());
// diagnoseIfNeeded(diagnosticsBlob);
if (!slangModule){
	printf("failed to compile slang shader");

	//ISlangBlob* diagnosticBlob = spGetDiagnosticOutput(request);
	if (diagnosticsBlob) {
		const char* diagnostics = (const char*)diagnosticsBlob->getBufferPointer();
		std::cerr << "Slang diagnostics:\n" << diagnostics << std::endl;
	}


	return nullptr;
}

ComPtr<IComponentType> linkedProgram;
{
	ComPtr<IBlob> diagnosticsBlob;
	SlangResult result = slangModule->link(
		linkedProgram.writeRef(),
		diagnosticsBlob.writeRef());
	// diagnoseIfNeeded(diagnosticsBlob);
	// SLANG_RETURN_ON_FAIL(result);
	if(!SLANG_SUCCEEDED(result)){
		printf("failed to link slang program");
		return nullptr;
	}
}

ComPtr<IBlob> spirvCode;
{
	ComPtr<IBlob> diagnosticsBlob;
	SlangResult result = linkedProgram->getTargetCode(
		0, // targetIndex
		spirvCode.writeRef(),
		diagnosticsBlob.writeRef());
	// diagnoseIfNeeded(diagnosticsBlob);
	// SLANG_RETURN_ON_FAIL(result);

	if(!SLANG_SUCCEEDED(result)){
		printf("failed to get slang program source code");
		return nullptr;
	}
}

Same error. id1 and id4 were again attempts to obtain the capability ID, but all of them return "unkown capability". Some of the docs seem to suggest that I should provide CompilerOptionName::Capability with an Int value of the CapabilityName enum, but I do not know how to obtain that integer value.

Thanks for any help!

[jkwak-work]

Sorry for not responding in time.
It seems like you figure it out.

The issue was that I did not put the slang.dll from v2025.19 in the binary folder, and I guess the application instead used the older slang.dll from the Vulkan SDK. A reminder for me to uninstall the VulkanSDK.

What was the platform?
I think this type of problem will be improved with a recent name change:

• Rename library from slang to slang-compiler and version library names #8746