I do not know which one, but it was the current version at the time of download dated November 26, 2015. But I remembered here that the error appeared after I tried to install the trial version (because when you announced a stable version 3.7 today, I tried to update several times through a luncher but all my attempts were in vain, and then I tried to install a new trial version through the site). And after that the error began to appear. Unfortunately, I cannot provide a more detailed STR (steps to reproduce).

All the same after update to 3.7 under OSX got error :bang: :bang: :bang: :

bash-3.2$ ./Spine
<JAVA_HOME>/lib/ext exists, extensions mechanism no longer supported; Use -classpath instead.
.2019-01-05 03:21:07.088 Spine[91439:7793089] Unable to create Java VM, error: -1

bash-3.2$ echo $JAVA_HOME
/Library/Java/JavaVirtualMachines/jdk1.8.0_51.jdk/Contents/Home
bash-3.2$ uname
Darwin
bash-3.2$ pwd
/Applications/Spine/Spine.app/Contents/MacOS

PS: Proposal to bypass this error through workaround by re-exporting an incorrect environment variable seems not solution at all. Because in this case I need always run Spine via my custom script.

bash-3.2$ JAVA_HOME=/asdf
bash-3.2$ export JAVA_HOME
bash-3.2$ ./Spine
<JAVA_HOME>/lib/ext exists, extensions mechanism no longer supported; Use -classpath instead.
.2019-01-05 03:38:17.292 Spine[91654:7802280] Unable to create Java VM, error: -1
bash-3.2$ /Applications/Spine/Spine.app/Contents/MacOS/Spine
<JAVA_HOME>/lib/ext exists, extensions mechanism no longer supported; Use -classpath instead.
.2019-01-05 03:38:32.990 Spine[91656:7802448] Unable to create Java VM, error: -1

Importent update:
After I was removed the Spine folder via

sudo rm -rf /Application/Spine

and reinstalled the error was gone

Nate escribió

It is part of the configuration of SkeletonJson and SkeletonBinary when loading skeleton data. Eg, with spine-libgdx, instead of the usual

I agree with you that a code with spine-libgdx looks easy with anonymous classes and it's beautiful overrides, but nevertheless it is a java. And what about C++? Specifically, I'm interested in spine-cocos2d-x interface, is it possible to get the same with a minimum of effort? Often I use:

SkeletonRenderer* SkeletonRenderer::createWithFile (const std::string& skeletonDataFile, const std::string& atlasFile, float scale)

How can I add a prefix with cocos2d-x? I myself will answer this question, it's not easy, because there is no OOP and OOD:

#include <spine/Cocos2dAttachmentLoader.h>
#include <spine/AttachmentVertices.h>
#include <spine/extension.h>

struct CustomAttachmentLoader {
    spAttachmentLoader super;
    spAtlasAttachmentLoader* atlasAttachmentLoader;
    std::string key;
};

static unsigned short quadTriangles[6] = {0, 1, 2, 2, 3, 0};

// just general approach
spAttachment* _CustomAttachmentLoader_createAttachment (spAttachmentLoader* loader, spSkin* skin, spAttachmentType type,
                                                         const char* name, const char* path) {
    CustomAttachmentLoader* self = SUB_CAST(CustomAttachmentLoader, loader);
    std::string newPath = self->key + "/";
    newPath += path;
    return spAttachmentLoader_createAttachment(SUPER(self->atlasAttachmentLoader), skin, type, name, newPath.c_str());
}

void _CustomAttachmentLoader_configureAttachment (spAttachmentLoader* loader, spAttachment* attachment) {
    attachment->attachmentLoader = loader;
    

switch (attachment->type) {
    case SP_ATTACHMENT_REGION: {
        spRegionAttachment* regionAttachment = SUB_CAST(spRegionAttachment, attachment);
        spAtlasRegion* region = (spAtlasRegion*)regionAttachment->rendererObject;
        AttachmentVertices* attachmentVertices = new AttachmentVertices((Texture2D*)region->page->rendererObject, 4, quadTriangles, 6);
        V3F_C4B_T2F* vertices = attachmentVertices->_triangles->verts;
        for (int i = 0, ii = 0; i < 4; ++i, ii += 2) {
            vertices[i].texCoords.u = regionAttachment->uvs[ii];
            vertices[i].texCoords.v = regionAttachment->uvs[ii + 1];
        }
        regionAttachment->rendererObject = attachmentVertices;
        break;
    }
    case SP_ATTACHMENT_MESH: {
        spMeshAttachment* meshAttachment = SUB_CAST(spMeshAttachment, attachment);
        spAtlasRegion* region = (spAtlasRegion*)meshAttachment->rendererObject;
        AttachmentVertices* attachmentVertices = new AttachmentVertices((Texture2D*)region->page->rendererObject,
                                                                        meshAttachment->super.worldVerticesLength >> 1, meshAttachment->triangles, meshAttachment->trianglesCount);
        V3F_C4B_T2F* vertices = attachmentVertices->_triangles->verts;
        for (int i = 0, ii = 0, nn = meshAttachment->super.worldVerticesLength; ii < nn; ++i, ii += 2) {
            vertices[i].texCoords.u = meshAttachment->uvs[ii];
            vertices[i].texCoords.v = meshAttachment->uvs[ii + 1];
        }
        meshAttachment->rendererObject = attachmentVertices;
        break;
    }
    default: ;
}
}

void _CustomAttachmentLoader_disposeAttachment (spAttachmentLoader* loader, spAttachment* attachment) {
    switch (attachment->type) {
        case SP_ATTACHMENT_REGION: {
            spRegionAttachment* regionAttachment = SUB_CAST(spRegionAttachment, attachment);
            delete (AttachmentVertices*)regionAttachment->rendererObject;
            break;
        }
        case SP_ATTACHMENT_MESH: {
            spMeshAttachment* meshAttachment = SUB_CAST(spMeshAttachment, attachment);
            delete (AttachmentVertices*)meshAttachment->rendererObject;
            break;
        }
        default: ;
    }
}

void _CustomAttachmentLoader_dispose (spAttachmentLoader* loader) {
    CustomAttachmentLoader* self = SUB_CAST(CustomAttachmentLoader, loader);
    spAttachmentLoader_dispose(SUPER_CAST(spAttachmentLoader, self->atlasAttachmentLoader));
    _spAttachmentLoader_deinit(loader);
}

RichAnimation::RichAnimation(const std::string& prefix) : _prefix(prefix) {
}

RichAnimation* RichAnimation::createWithJsonFile (const std::string& prefix, const std::string& skeletonJsonFile, spAtlas* atlas, float scale) {
    RichAnimation* node = new RichAnimation(prefix);
    node->initWithJsonFileExtend(skeletonJsonFile, atlas, scale);
    node->autorelease();
    return node;
}

RichAnimation* RichAnimation::createWithJsonFile (const std::string& prefix, const std::string& skeletonJsonFile, const std::string& atlasFile, float scale) {
    RichAnimation* node = new RichAnimation(prefix);
    spAtlas* atlas = spAtlas_createFromFile(atlasFile.c_str(), 0);
    node->initWithJsonFileExtend(skeletonJsonFile, atlas, scale);
    node->autorelease();
    return node;
}

RichAnimation* RichAnimation::createWithBinaryFile (const std::string& prefix, const std::string& skeletonBinaryFile, spAtlas* atlas, float scale) {
    RichAnimation* node = new RichAnimation(prefix);
    node->initWithBinaryFileExtend(skeletonBinaryFile, atlas, scale);
    node->autorelease();
    return node;
}

RichAnimation* RichAnimation::createWithBinaryFile (const std::string& prefix, const std::string& skeletonBinaryFile, const std::string& atlasFile, float scale) {
    RichAnimation* node = new RichAnimation(prefix);
    spAtlas* atlas = spAtlas_createFromFile(atlasFile.c_str(), 0);
    node->initWithBinaryFileExtend(skeletonBinaryFile, atlas, scale);
    node->autorelease();
    return node;
}

void RichAnimation::initWithJsonFileExtend (const std::string& skeletonDataFile, spAtlas* atlas, float scale) {
    _atlas = atlas;
    createCustomAttachmentLoader(_atlas);
    

spSkeletonJson* json = spSkeletonJson_createWithLoader(_attachmentLoader);
json->scale = scale;
spSkeletonData* skeletonData = spSkeletonJson_readSkeletonDataFile(json, skeletonDataFile.c_str());
CCASSERT(skeletonData, json->error ? json->error : "Error reading skeleton data.");
spSkeletonJson_dispose(json);

setSkeletonData(skeletonData, true);

initialize();
}

void RichAnimation::initWithJsonFileExtend (const std::string& skeletonDataFile, const std::string& atlasFile, float scale) {
    _atlas = spAtlas_createFromFile(atlasFile.c_str(), 0);
    CCASSERT(_atlas, "Error reading atlas file.");
    

createCustomAttachmentLoader(_atlas);

spSkeletonJson* json = spSkeletonJson_createWithLoader(_attachmentLoader);
json->scale = scale;
spSkeletonData* skeletonData = spSkeletonJson_readSkeletonDataFile(json, skeletonDataFile.c_str());
CCASSERT(skeletonData, json->error ? json->error : "Error reading skeleton data file.");
spSkeletonJson_dispose(json);

setSkeletonData(skeletonData, true);

initialize();
}

void RichAnimation::initWithBinaryFileExtend (const std::string& skeletonDataFile, spAtlas* atlas, float scale) {
    _atlas = atlas;
    createCustomAttachmentLoader(_atlas);
    

spSkeletonBinary* binary = spSkeletonBinary_createWithLoader(_attachmentLoader);
binary->scale = scale;
spSkeletonData* skeletonData = spSkeletonBinary_readSkeletonDataFile(binary, skeletonDataFile.c_str());
CCASSERT(skeletonData, binary->error ? binary->error : "Error reading skeleton data file.");
spSkeletonBinary_dispose(binary);

setSkeletonData(skeletonData, true);

initialize();
}

void RichAnimation::initWithBinaryFileExtend (const std::string& skeletonDataFile, const std::string& atlasFile, float scale) {
    _atlas = spAtlas_createFromFile(atlasFile.c_str(), 0);
    CCASSERT(_atlas, "Error reading atlas file.");
    

createCustomAttachmentLoader(_atlas);

spSkeletonBinary* binary = spSkeletonBinary_createWithLoader(_attachmentLoader);
binary->scale = scale;
spSkeletonData* skeletonData = spSkeletonBinary_readSkeletonDataFile(binary, skeletonDataFile.c_str());
CCASSERT(skeletonData, binary->error ? binary->error : "Error reading skeleton data file.");
spSkeletonBinary_dispose(binary);

setSkeletonData(skeletonData, true);

initialize();
}

void RichAnimation::createCustomAttachmentLoader (spAtlas* atlas) {
    CustomAttachmentLoader* self = NEW(CustomAttachmentLoader);
    _spAttachmentLoader_init(SUPER(self), _CustomAttachmentLoader_dispose, _CustomAttachmentLoader_createAttachment,
                             _CustomAttachmentLoader_configureAttachment, _CustomAttachmentLoader_disposeAttachment);
    self->atlasAttachmentLoader = spAtlasAttachmentLoader_create(atlas);
    self->key = _prefix;
    _attachmentLoader = &self->super;
}

As I understand you right, in the situation I described above, the end user does not have any opportunity to use the shared atlas "as is" without AtlasAttachmentLoader or other modification. In the same time there are no software options at Spine to solve this problem if artist used the same names in different spine files.

This is because the Spine/or spine-runtime considers the value of skeleton.images in skeleton file unnecessary and nonessential. The value of skeleton.images used only by Spine GUI when user want import skeleton to spine but ignored in runtime during search within atlas (as alternative way to get necessary entry when searching texture key, [like $PATH variable worked in OS]).

Both approaches are not good if it's out the box of spine and need additional programming activity from developer side.
In the first case, we get "The texture is not found" via runtime, because a skeleton has a broken reference to "head" and has not reference to shared "hero1/head".
In second case, of course, you can use the manual mode by Find and Replace operation in Spine GUI, but this works for "poor" models and with the number of 10-20, but when it comes to 100+ "rich" models with skins, frame-by-frame animations etc, so it turns into a manual hell. :broken:
My idea is that anything which worked with separate atlases should work within the shared atlas without any additional developer's activities. Because there were no physical changes, there was just a logical redistribution of objects in memory to better performance, this should not work differently than expected before.

Is there any chance to import a skeleton file into the Spine via command line interface? I have about 100 spine models with textures and I'm gonna to pack textures in one atlas (because of performance). The problem is that the artist called the textures by similar names, and I have 100 heads, 100 hands... in separated folders but when I tried to get one shared atlas, you know, I found one big problem... I sorted out the problem with my handmade utility which renames the textures with new names and its names within json (exported from spine file) file but i can't do backward import into the spine for the future creation of shared atlas .
Looks like it's not described itself by documentation http://esotericsoftware.com/spine-export#Command-line ?

The issue is fully reproducible, when you fix that? My snippet is here:

SpinePath="/Applications/Spine/Spine.app/Contents/MacOS/Spine"
# Sets the parameters ...
$SpinePath 

---

notimeout $PARAMS -i $INPUT_DIR -o $OUTPUT_DIR -p ./config.json
echo "Exited."

and in terminal you will see something like it:

Spine Launcher 3.4.00
Mac OS X x86_64 10.13.2
Java 1.7.0_51 Esoteric Software
64-bit Server VM
Spine 3.6.48 Professional
Licensed to: *****, *****
ATI Technologies Inc.
AMD Radeon R9 M370X OpenGL Engine
2.1 ATI-1.60.24
JSON export: ....
JSON export: ....
JSON export: ....
JSON export: ....
JSON export: ...
...
Packing...
Writing 1024x1024: ...../output/0.5/.....png
Complete.

In the end of script Spine is stuck (in my example it's never shows "Exited."), if you change focus from terminal to GUI Spine application the application will exited (Shows "Exited." from echo command). But without focus on spine it will stay stuck all time.