I am trying to create a simple executable using the Max SDK to read data from HDF5 and write it to a Jitter Matrix in .jxf format. However, when I trace the dependencies of my executable I find that it depends on Max.exe. This seems to prohibit me from ever distributing this to someone who doesn't have a Max license. Is the SDK only meant to be used to create dlls that will run inside Max, or is there also a way to create a dll/executable that does not depend on the main Max executable?

My use case is that I have a larger C++ based project with an audio component running in Max, communicating through OSC messages. I will distribute the C++ executable together with a Max standalone. I want to pre-process the input data from .hdf5 to .jxf from inside the C++ part, as that seems less of a hassle than trying to find a way to read .hdf5 inside Max, and I don't want to go through a non-binary format due to loading times.

If there is another obvious way to satisfy my use case without the Max SDK that would be very welcome as well.

I am trying to create a simple executable using the Max SDK to read data from HDF5 and write it to a Jitter Matrix in .jxf format. However, 

using-the-max-sdk-without-max-exe

for the most part I would say yes. There is a 

 distributed as part of the testing framework with the 

however if all you'd like to do is write out matrix binaries to files, I can send you some code snippets that show how we we do that internally, which you should be able incorporate in your app.

Is the SDK only meant to be used to create dlls that will run inside Max,

for the most part I would say yes. There is a mock kernel distributed as part of the testing framework with the min-devkit, that may be of interest.

Thanks for the quick response. The min-devkit sounds promising. However, this:

is indeed the only thing I want to do. So if you are willing and able to share code snippets that show me how to do that, that would be extremely helpful.

if all you'd like to do is write out matrix binaries to files, I can send you some code snippets that show how we we do that internally, which you should be able incorporate in your app.

the jit_bin_write_header function looks like this, and contains definitions that are found in 

 from the max-sdk c74support/jit-includes folder:

the jit_bin_write_matrix function simply writes out the matrix-chunk info, the dim info, and then the data:

jit_bin_write_header(fh,0);
jit_bin_write_matrix(fh,o);
sysfile_getpos(fh, &position);
sysfile_seteof(fh, position);
jit_bin_write_header(fh,(long) position);

the jit_bin_write_header function looks like this, and contains definitions that are found in jit.bin.h and jit.byteorder.h from the max-sdk c74support/jit-includes folder:

t_jit_err jit_bin_write_header(t_filehandle fh, t_int32 filesize)
{
	t_atom_long err=JIT_ERR_NONE;
	t_ptr_size size;
	t_int32 tmp[6];
	if (fh) {
		tmp[0] = BE_I32(JIT_BIN_CHUNK_CONTAINER);
		tmp[1] = BE_I32(filesize);
		tmp[2] = BE_I32(JIT_BIN_FORMAT);
		tmp[3] = BE_I32(JIT_BIN_CHUNK_FORMAT_VERSION);
		tmp[4] = BE_I32(12);
		tmp[5] = BE_I32(JIT_BIN_VERSION_1);
		size=JIT_BIN_HEADER_SIZE;
		sysfile_setpos(fh,SYSFILE_FROMSTART,0);
		err = sysfile_write(fh, &size, &tmp); 
	} else {
		err = JIT_ERR_INVALID_PTR;
	}
	return err;
}

t_jit_err jit_bin_write_matrix(t_filehandle fh, void *matrix)
{
	t_atom_long err = JIT_ERR_NONE;
	t_int32 i;
	t_jit_matrix_info info;
	t_int32 dim[JIT_MATRIX_MAX_DIMCOUNT];
	char *bp;
	t_atom_long savelock;
	t_int32 tmp[JIT_MATRIX_MAX_DIMCOUNT],cksize,offset,points,typesize,typeID;
	t_ptr_size size; 
	if (fh&&matrix) {
		savelock = (t_atom_long) jit_object_method(matrix,gensym("lock"),1);
		jit_object_method(matrix,gensym("getinfo"), &info);
		jit_object_method(matrix, gensym("getdata"), &bp);
		if (!bp) { err=JIT_ERR_GENERIC; goto out;}
		cksize = JIT_BIN_HEADER_SIZE;
		points = 1;
		for (i = 0; i < info.dimcount; i++) {
			dim[i] = info.dim[i];
			cksize += SIZE_INT32;
			points *= dim[i]; 
		}
		if (info.type==_jit_sym_char) {
			typeID 		= JIT_BIN_TYPE_CHAR;
			typesize 	= 1;
		} else if (info.type==_jit_sym_long) {
			typeID 		= JIT_BIN_TYPE_LONG;
			typesize 	= SIZE_INT32;
		} else if (info.type==_jit_sym_float32) {
			typeID 		= JIT_BIN_TYPE_FLOAT32;
			typesize 	= SIZE_FLOAT32;
		} else if (info.type==_jit_sym_float64) {
			typeID 		= JIT_BIN_TYPE_FLOAT64;
			typesize 	= SIZE_FLOAT64;
		} else {
			err = JIT_ERR_GENERIC;
			goto out;
		}
		offset = cksize;
		cksize += points*info.planecount*typesize;
		//write standard matrix chunk info
		tmp[0] = BE_I32(JIT_BIN_CHUNK_MATRIX);
		tmp[1] = BE_I32(cksize);
		tmp[2] = BE_I32(offset);		
		tmp[3] = BE_I32(typeID);
		tmp[4] = BE_I32(info.planecount);
		tmp[5] = BE_I32(info.dimcount);
		size = JIT_BIN_HEADER_SIZE;
		if ((err = sysfile_write(fh, &size, &tmp))) {
			goto out; 
		}
		//write dim values
		for (i=0;i<info.dimcount;i++) 
			tmp[i] = BE_I32(dim[i]);
		size = info.dimcount*SIZE_INT32;
		if ((err = sysfile_write(fh, &size, &tmp))) {
			goto out; 
		}
		//write the data

Thanks for the help! I have basic .jxf export functionality working now, and can build on that.

Using the Max SDK without Max.exe?