coremlcompiler

package
v0.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Mar 11, 2026 License: MIT Imports: 10 Imported by: 0

Documentation

Overview

Package coremlcompiler compiles CoreML model packages (.mlpackage) into compiled model bundles (.mlmodelc) without requiring xcrun or Apple's proprietary coremlcompiler binary.

The primary path converts mlprogram models: the protobuf-encoded MIL program is serialized to MIL text, weights are copied byte-for-byte, and a coremldata.bin header is generated. The result can be loaded directly by CoreML, the ANE runtime, or x/ane.

err := coremlcompiler.Compile("model.mlpackage", "model.mlmodelc")
Example
package main

import (
	"fmt"

	"github.com/tmc/apple/x/coremlcompiler"
)

func main() {
	// Compile a CoreML model package to a compiled bundle.
	err := coremlcompiler.Compile("model.mlpackage", "model.mlmodelc")
	if err != nil {
		fmt.Println(err)
	}

	// The compiled bundle can be loaded by CoreML or x/ane:
	//
	//   rt, _ := ane.Open()
	//   k, _ := rt.Compile(ane.CompileOptions{
	//       ModelType:   ane.ModelTypePackage,
	//       PackagePath: "model.mlmodelc",
	//   })
}

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func Compile

func Compile(inputPath, outputPath string) error

Compile compiles a CoreML model package (.mlpackage) or model file (.mlmodel) into a compiled bundle (.mlmodelc) at outputPath.

Currently supports mlprogram models. NeuralNetwork models will be supported in a future release.

func CompileMILText

func CompileMILText(milText string, specVersion int32, desc ModelDescription, weightRoot, outputPath string) error

CompileMILText compiles an already-emitted mlprogram MIL text into a compiled bundle at outputPath.

desc names the model inputs, outputs, and states stored in coremldata.bin and metadata.json. weightRoot, when non-empty, is copied into the bundle preserving relative paths, so BLOBFILE paths like "@model_path/weights/..." resolve correctly at runtime.

Example
package main

import (
	"fmt"
	"os"
	"path/filepath"

	"github.com/tmc/apple/x/coremlcompiler"
)

func main() {
	tmpDir, err := os.MkdirTemp("", "coremlcompiler-example-*")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer os.RemoveAll(tmpDir)

	milText := `program(1.3) {
    func main<ios18>(tensor<fp16, [1, 8]> x) {
    } -> (x);
}`
	desc := coremlcompiler.ModelDescription{
		Inputs:  []coremlcompiler.FeatureDescription{{Name: "x"}},
		Outputs: []coremlcompiler.FeatureDescription{{Name: "x"}},
	}
	err = coremlcompiler.CompileMILText(milText, 8, desc, "", filepath.Join(tmpDir, "model.mlmodelc"))
	if err != nil {
		fmt.Println(err)
	}
}

func CompileMLProgram

func CompileMLProgram(modelProto []byte, weightDir, outputPath string) error

CompileMLProgram compiles an mlprogram model from already-parsed components. This is useful when you have the model proto bytes and weight directory available separately.

func CompileToTemp

func CompileToTemp(inputPath string) (string, error)

CompileToTemp compiles a model to a temporary directory, returning the path to the compiled .mlmodelc bundle. The directory is placed under os.TempDir() and named by a hash of the input path for implicit caching.

Types

type Argument

type Argument struct {
	Bindings []Binding // field 1
}

Argument is an operation input (list of bindings). Proto: MILSpec.Argument

type ArrayDataType

type ArrayDataType int32

ArrayDataType identifies Core ML multi-array element types.

const (
	ArrayDataTypeInvalid ArrayDataType = 0
	ArrayDataTypeFloat16 ArrayDataType = 65552
	ArrayDataTypeFloat32 ArrayDataType = 65568
	ArrayDataTypeDouble  ArrayDataType = 65600
	ArrayDataTypeInt32   ArrayDataType = 131104
)

type ArrayFeatureType

type ArrayFeatureType struct {
	Shape    []int64
	DataType ArrayDataType
}

ArrayFeatureType describes a Core ML multi-array feature.

type Binding

type Binding struct {
	Name  string // field 1 (oneof)
	Value *Value // field 2 (oneof)
}

Binding is either a name reference or an inline value. Proto: MILSpec.Argument.Binding

type BlobFileValue

type BlobFileValue struct {
	FileName string // field 1
	Offset   uint64 // field 2
}

BlobFileValue references weight data in a blob file. Proto: MILSpec.BlobFileValue

type Block

type Block struct {
	Inputs     []NamedValueType // field 1
	Outputs    []string         // field 2
	Operations []*Operation     // field 3
}

Block is a sequence of operations. Proto: MILSpec.Block

type DataType

type DataType int32

DataType identifies element types in MIL. Proto: MILSpec.DataType

const (
	DataTypeFloat16  DataType = 10
	DataTypeFloat32  DataType = 11
	DataTypeFloat64  DataType = 12
	DataTypeBFloat16 DataType = 13
	DataTypeInt8     DataType = 21
	DataTypeInt16    DataType = 22
	DataTypeInt32    DataType = 23
	DataTypeInt64    DataType = 24
	DataTypeInt4     DataType = 25
	DataTypeUInt8    DataType = 31
	DataTypeUInt16   DataType = 32
	DataTypeUInt32   DataType = 33
	DataTypeUInt64   DataType = 34
	DataTypeBool     DataType = 1
	DataTypeString   DataType = 2
)

func (DataType) String

func (dt DataType) String() string

String returns the MIL text name for the data type.

type Dimension

type Dimension struct {
	Constant uint64 // from ConstantDimension.size (field 1.1)
	Unknown  bool   // true if UnknownDimension
}

Dimension is a tensor dimension (constant or unknown). Proto: MILSpec.Dimension

type FeatureDescription

type FeatureDescription struct {
	Name string       // field 1
	Type *FeatureType // field 3
}

FeatureDescription is a named, typed model feature. Proto: CoreML.Specification.FeatureDescription

type FeatureType

type FeatureType struct {
	MultiArrayType *ArrayFeatureType
	IsOptional     bool
}

FeatureType describes a Core ML model feature type.

type Function

type Function struct {
	Inputs               []NamedValueType  // field 1
	OpSet                string            // field 2
	BlockSpecializations map[string]*Block // field 3
	Attributes           map[string]*Value // field 4
}

Function is an MIL function. Proto: MILSpec.Function

type ImmediateValue

type ImmediateValue struct {
	// Exactly one of these is set.
	Tensor *TensorValue // field 1
}

ImmediateValue holds inline constant data. Proto: MILSpec.ImmediateValue

type Model

type Model struct {
	SpecVersion int32            // field 1
	Description ModelDescription // field 2
	MLProgram   *Program         // field 502 (oneof)
	// contains filtered or unexported fields
}

Model is the top-level CoreML model container. Proto: CoreML.Specification.Model

type ModelDescription

type ModelDescription struct {
	Inputs  []FeatureDescription // field 1
	Outputs []FeatureDescription // field 10
	States  []FeatureDescription // field 13
}

ModelDescription describes model inputs, outputs, and metadata. Proto: CoreML.Specification.ModelDescription

type NamedValueType

type NamedValueType struct {
	Name string     // field 1
	Type *ValueType // field 2
}

NamedValueType is a (name, type) pair. Proto: MILSpec.NamedValueType

type Operation

type Operation struct {
	Type       string               // field 1
	Inputs     map[string]*Argument // field 2
	Outputs    []NamedValueType     // field 3
	Blocks     []*Block             // field 4
	Attributes map[string]*Value    // field 5
}

Operation is a single MIL operation. Proto: MILSpec.Operation

type Program

type Program struct {
	Version    int64                // field 1
	Functions  map[string]*Function // field 2
	Attributes map[string]*Value    // field 4
}

Program is an MIL program. Proto: MILSpec.Program

type StateType

type StateType struct {
	WrappedType *ValueType // field 1
}

StateType wraps a ValueType for stateful operations. Proto: MILSpec.StateType

type TensorType

type TensorType struct {
	DataType   DataType    // field 1
	Rank       int64       // field 2
	Dimensions []Dimension // field 3
}

TensorType describes a tensor's element type and shape. Proto: MILSpec.TensorType

type TensorValue

type TensorValue struct {
	// Exactly one of these is set.
	Floats  []float32 // field 1
	Ints    []int32   // field 2
	Bools   []bool    // field 3
	Strings []string  // field 4
	Longs   []int64   // field 5
	Doubles []float64 // field 6
	Bytes   []byte    // field 7
}

TensorValue holds tensor data inline. Proto: MILSpec.TensorValue

type Value

type Value struct {
	Type *ValueType // field 2

	// Exactly one of these is set.
	Immediate *ImmediateValue // field 3
	BlobFile  *BlobFileValue  // field 5
}

Value is an MIL value (immediate or blob reference). Proto: MILSpec.Value

type ValueType

type ValueType struct {
	// Exactly one of these is set.
	TensorType *TensorType // field 1
	StateType  *StateType  // field 5

}

ValueType describes a MIL value's type. Proto: MILSpec.ValueType

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL