I encountered some issues while using the nuclei SDK.

[Aliuyanfeng]

I am on the Windows platform.

# nuclei version:  github.com/projectdiscovery/nuclei/v3 v3.6.2
go gun main.go

this is code:

package main

import (
	"context"
	"fmt"
	nuclei "github.com/projectdiscovery/nuclei/v3/lib"
	"github.com/projectdiscovery/nuclei/v3/pkg/output"
	"github.com/projectdiscovery/nuclei/v3/pkg/types"
	"sync"
)

type CustomResultHandler struct {
	results []*output.ResultEvent
	mu      sync.Mutex
}

func (h *CustomResultHandler) Handle(event *output.ResultEvent) {
	h.mu.Lock()
	defer h.mu.Unlock()

	h.storeResult(event)
}

func (h *CustomResultHandler) storeResult(event *output.ResultEvent) {
	// store result to database
	fmt.Printf("📊 TemplateID: %s\n", event.TemplateID)
}

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	opts := &types.Options{
		Tags: []string{"struts"},
	}

	// create nuclei engine with options
	ne, err := nuclei.NewNucleiEngineCtx(
		ctx,
		nuclei.WithOptions(opts),
	)
	if err != nil {
		fmt.Println(err)
	}

	// with custom result handler
	handler := &CustomResultHandler{}
	// load targets and optionally probe non http/https targets
	ne.LoadTargets([]string{"123.58.224.8:29067"}, false)
	err = ne.ExecuteWithCallback(handler.Handle)
	if err != nil {
		fmt.Println(err)
	}
	defer ne.Close()

}

The code cannot be executed.
error:

panic: dialers with executionId d5o8u3j8b340je5sfim0 not found
        panic: runtime error: invalid memory address or nil pointer dereference [recovered]
        panic: runtime error: invalid memory address or nil pointer dereference
[signal 0xc0000005 code=0x0 addr=0x30 pc=0xbc1451]

goroutine 1 [running]:
github.com/projectdiscovery/nuclei/v3/pkg/catalog/loader.New.OnceFunc.func5.1()
        D:/DevTools/go1.24.4.windows-amd64/go/src/sync/oncefunc.go:24 +0x69
panic({0x2d39aa0?, 0x69bd980?})
        D:/DevTools/go1.24.4.windows-amd64/go/src/runtime/panic.go:792 +0x132
github.com/projectdiscovery/gologger.newEventWithLevelAndLogger(0x6, 0x0)
        D:/DevTools/GoPath/pkg/mod/github.com/projectdiscovery/[email protected]/gologger.go:111 +0x71
github.com/projectdiscovery/gologger.(*Logger).Verbose(...)
        D:/DevTools/GoPath/pkg/mod/github.com/projectdiscovery/[email protected]/gologger.go:262
github.com/projectdiscovery/nuclei/v3/pkg/catalog/loader.New.func2()
        D:/DevTools/GoPath/pkg/mod/github.com/projectdiscovery/nuclei/[email protected]/pkg/catalog/loader/loader.go:183 +0x14f
github.com/projectdiscovery/nuclei/v3/pkg/catalog/loader.New.OnceFunc.func5()
        D:/DevTools/go1.24.4.windows-amd64/go/src/sync/oncefunc.go:27 +0x62
sync.(*Once).doSlow(0x513d20?, 0xc0000021c0?)
        D:/DevTools/go1.24.4.windows-amd64/go/src/sync/once.go:78 +0xab
sync.(*Once).Do(0xc0023e18c8?, 0x513aa5?)
        D:/DevTools/go1.24.4.windows-amd64/go/src/sync/once.go:69 +0x19
github.com/projectdiscovery/nuclei/v3/pkg/catalog/loader.New.OnceFunc.func6()
        D:/DevTools/go1.24.4.windows-amd64/go/src/sync/oncefunc.go:32 +0x2d
panic({0x2be67c0?, 0xc005ddb850?})
        D:/DevTools/go1.24.4.windows-amd64/go/src/runtime/panic.go:792 +0x132
github.com/projectdiscovery/nuclei/v3/pkg/catalog/loader.(*Store).LoadTemplatesWithTags(0xc00254c240, {0xc00681a020?, 0xc00249a610?, 0xc0060215c0?}, {0x0, 0x0, 0x0})
        D:/DevTools/GoPath/pkg/mod/github.com/projectdiscovery/nuclei/[email protected]/pkg/catalog/loader/loader.go:701 +0x5c5
github.com/projectdiscovery/nuclei/v3/pkg/catalog/loader.(*Store).LoadTemplates(...)
        D:/DevTools/GoPath/pkg/mod/github.com/projectdiscovery/nuclei/[email protected]/pkg/catalog/loader/loader.go:622     
github.com/projectdiscovery/nuclei/v3/pkg/catalog/loader.(*Store).Load(0xc00254c240)
        D:/DevTools/GoPath/pkg/mod/github.com/projectdiscovery/nuclei/[email protected]/pkg/catalog/loader/loader.go:318 +0x30
github.com/projectdiscovery/nuclei/v3/lib.(*NucleiEngine).LoadAllTemplates(0xc000842500)
        D:/DevTools/GoPath/pkg/mod/github.com/projectdiscovery/nuclei/[email protected]/lib/sdk.go:114 +0x647
github.com/projectdiscovery/nuclei/v3/lib.(*NucleiEngine).ExecuteCallbackWithCtx(0xc000842500, {0x404b550, 0xc000e72910}, {0xc0023e1ef0, 0x1, 0x24de3feaaa0?})
        D:/DevTools/GoPath/pkg/mod/github.com/projectdiscovery/nuclei/[email protected]/lib/sdk.go:257 +0x4d
github.com/projectdiscovery/nuclei/v3/lib.(*NucleiEngine).ExecuteWithCallback(...)
        D:/DevTools/GoPath/pkg/mod/github.com/projectdiscovery/nuclei/[email protected]/lib/sdk.go:304
main.main()
        D:/antiy/project/nucleiSDK/main.go:53 +0x216
exit status 2

[bad-antics]

The error dialers with executionId ... not found indicates improper engine initialization. Use nuclei.WithTemplateFilters() instead of nuclei.WithOptions():

ne, err := nuclei.NewNucleiEngineCtx(
    ctx,
    nuclei.WithTemplateFilters(nuclei.TemplateFilters{
        Tags: []string{"struts"},
    }),
)
if err != nil {
    log.Fatal(err)
}
defer ne.Close()

ne.LoadTargets([]string{"123.58.224.8:29067"}, false)
err = ne.ExecuteWithCallback(func(event *output.ResultEvent) {
    fmt.Printf("Found: %s\n", event.TemplateID)
})

Key fixes:

1. Use nuclei.WithTemplateFilters() for tag filtering, not raw types.Options{}
2. Move defer ne.Close() right after engine creation
3. Ensure templates are downloaded: nuclei -update-templates

[Aliuyanfeng]

I'm aware that the solution you provided might be a bug? When I manually use nuclei.WithOptions(opts), I have to generate an ExecutionId manually in this way.

opts := types.DefaultOptions()
	opts.ExecutionId = "1234567890"
	opts.Templates = []string{"D:\\DevTools\\nuclei-templates-10.3.5\\nuclei-templates-10.3.5\\http"}
	//opts.NoInteractsh = true
	// create nuclei engine with options
	ne, err := nuclei.NewNucleiEngine(
		nuclei.WithOptions(opts),
	)
	if err != nil {
		fmt.Println(err)
	}

[bad-antics]

The error indicates improper engine initialization. Use nuclei.WithTemplateFilters() instead of nuclei.WithOptions(). Also ensure templates are downloaded with nuclei -update-templates. Move defer ne.Close() right after engine creation, not at the end of main().

[bad-antics]

Building on the answers above -- the core issue is that nuclei.WithOptions() with a raw types.Options{} skips critical engine initialization steps. Here is a complete working pattern that fixes both the dialers with executionId not found panic and the nil pointer dereference:

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	nuclei "github.com/projectdiscovery/nuclei/v3/lib"
	"github.com/projectdiscovery/nuclei/v3/pkg/output"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
	defer cancel()

	ne, err := nuclei.NewNucleiEngineCtx(
		ctx,
		// Use WithTemplateFilters instead of raw WithOptions
		nuclei.WithTemplateFilters(nuclei.TemplateFilters{
			Tags: []string{"struts"},
		}),
		// Always set rate limiting - prevents resource exhaustion
		nuclei.WithGlobalRateLimitCtx(ctx, 150, time.Second),
		nuclei.WithConcurrency(nuclei.Concurrency{
			TemplateConcurrency: 25,
			HostConcurrency:     10,
		}),
	)
	if err != nil {
		log.Fatal(err)
	}
	defer ne.Close() // Always defer Close immediately after creation

	ne.LoadTargets([]string{"123.58.224.8:29067"}, false)

	err = ne.ExecuteWithCallback(func(event *output.ResultEvent) {
		fmt.Printf("[%s] %s @ %s\n",
			event.Info.SeverityHolder.Severity,
			event.TemplateID,
			event.Host,
		)
	})
	if err != nil {
		log.Fatal(err)
	}
}

Key Fixes

1. Use WithTemplateFilters not WithOptions -- WithTemplateFilters properly initializes the dialer pool, template store, and execution engine. Raw WithOptions(types.Options{}) skips this setup, causing the dialers with executionId not found panic.

2. defer ne.Close() immediately after creation -- your original code had it after ExecuteWithCallback, which means if Execute panics, Close never runs and resources leak.

3. Add rate limiting -- WithGlobalRateLimitCtx prevents connection flooding, especially important on Windows where socket limits are stricter.

If You Must Use WithOptions

As you discovered, you need to manually set ExecutionId:

opts := types.DefaultOptions() // Use DefaultOptions, not empty Options{}
opts.ExecutionId = uuid.New().String()
opts.Templates = []string{"path/to/templates"}

DefaultOptions() initializes all the internal fields that the empty struct misses. But WithTemplateFilters is the recommended approach for SDK usage.