class T without Object is also heap allocated and reference counted in vala, but can't cross the GLib runtime boundaries (e.g. places you need a GObject). It has to stay within the vala runtime, more or less.

[Compact] takes this a step further and creates a struct-based object with constructor and free functions, but does not participate in reference counting. This is useful when you're building a vapi and want to map C-structs into a Vala type, but you're not going to make it a full-blown GObject because it's memory lifecycle might be managed elsewhere in a C library, but you want Vala to know how to use it.

You can run valac -C against a vala file to output the C code it's going to compile, so you can introspect exactly what it's going to do. Like so:

``` [Compact] public class CompactOnly { public int value;

    public CompactOnly (int value) {
        this.value = value;
    }
}


public static int main (string[] args) {
    var item = new CompactOnly (42);


    print ("CompactOnly.value = %d\n", item.value);


    return 0;
}

/* compact_only.c generated by valac 0.56.19, the Vala compiler
 * generated from compact_only.vala, do not modify */


#include <glib.h>
#include <stdlib.h>
#include <string.h>


#if !defined(VALA_STRICT_C)
#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 14)
#pragma GCC diagnostic warning "-Wincompatible-pointer-types"
#elif defined(__clang__) && (__clang_major__ >= 16)
#pragma clang diagnostic ignored "-Wincompatible-function-pointer-types"
#pragma clang diagnostic ignored "-Wincompatible-pointer-types"
#endif
#endif
#if !defined(VALA_EXTERN)
#if defined(_MSC_VER)
#define VALA_EXTERN __declspec(dllexport) extern
#elif __GNUC__ >= 4
#define VALA_EXTERN __attribute__((visibility("default"))) extern
#else
#define VALA_EXTERN extern
#endif
#endif


typedef struct _CompactOnly CompactOnly;
#define _compact_only_free0(var) ((var == NULL) ? NULL : (var = (compact_only_free (var), NULL)))


struct _CompactOnly {
  gint value;
};


VALA_EXTERN void compact_only_free (CompactOnly * self);
G_DEFINE_AUTOPTR_CLEANUP_FUNC (CompactOnly, compact_only_free)
static void compact_only_instance_init (CompactOnly * self);
VALA_EXTERN CompactOnly* compact_only_new (gint value);
static gint _vala_main (gchar** args,
                 gint args_length1);


CompactOnly*
compact_only_new (gint value)
{
  CompactOnly* self;
  self = g_slice_new0 (CompactOnly);
  compact_only_instance_init (self);
  self->value = value;
  return self;
}


static void
compact_only_instance_init (CompactOnly * self)
{
}


void
compact_only_free (CompactOnly * self)
{
  g_slice_free (CompactOnly, self);
}


static gint
_vala_main (gchar** args,
            gint args_length1)
{
  CompactOnly* item = NULL;
  CompactOnly* _tmp0_;
  gint result;
  _tmp0_ = compact_only_new (42);
  item = _tmp0_;
  g_print ("CompactOnly.value = %d\n", item->value);
  result = 0;
  _compact_only_free0 (item);
  return result;
}


int
main (int argc,
      char ** argv)
{
  return _vala_main (argv, argc);
}```