@@ -48,7 +48,13 @@
     FuncIR,
     get_text_signature,
 )
-from mypyc.ir.rtypes import RTuple, RType, is_simple_refcounted_pointer, object_rprimitive
+from mypyc.ir.rtypes import (
+    RTuple,
+    RType,
+    is_int_rprimitive,
+    is_simple_refcounted_pointer,
+    object_rprimitive,
+)
 from mypyc.namegen import NameGenerator
 from mypyc.sametype import is_same_type
 
@@ -1393,6 +1399,20 @@ def generate_getter(cl: ClassIR, attr: str, rtype: RType, emitter: Emitter) -> N
         emitter.emit_line("}")
         return
 
+    if IS_FREE_THREADED and is_int_rprimitive(rtype) and attr not in cl.final_attributes:
+        # In free-threaded builds, CPyTagged_GetAttr takes a new reference to a long
+        # value without racing with a concurrent setter (see CPyTagged_SetAttr). It
+        # returns CPY_INT_TAG if the attribute is undefined.
+        emitter.emit_line(f"CPyTagged tmp = CPyTagged_GetAttr((PyObject *)self, &{attr_expr});")
+        emitter.emit_line("if (unlikely(tmp == CPY_INT_TAG)) {")
+        emitter.emit_line("PyErr_SetString(PyExc_AttributeError,")
+        emitter.emit_line(f'    "attribute {repr(attr)} of {repr(cl.name)} undefined");')
+        emitter.emit_line("return NULL;")
+        emitter.emit_line("}")
+        emitter.emit_line("return CPyTagged_StealAsObject(tmp);")
+        emitter.emit_line("}")
+        return
+
     # HACK: Don't consider refcounted values as always defined, since it's possible to
     #       access uninitialized values via 'gc.get_objects()'. Accessing non-refcounted
     #       values is benign.
@@ -1459,6 +1479,28 @@ def generate_setter(cl: ClassIR, attr: str, rtype: RType, emitter: Emitter) -> N
         emitter.emit_line("}")
         return
 
+    if IS_FREE_THREADED and is_int_rprimitive(rtype):
+        # In free-threaded builds, CPyTagged_SetAttr steals the new value and safely
+        # reclaims the old one (see CPyTagged_GetAttr). Unbox (borrowed) and take a
+        # new reference to hand over; a failed unbox leaves the attribute intact.
+        # CPY_INT_TAG deletes the attribute.
+        if deletable:
+            emitter.emit_line("if (value != NULL) {")
+        emitter.emit_unbox(
+            "value", "tmp", rtype, error=ReturnHandler("-1"), declare_dest=True, borrow=True
+        )
+        emitter.emit_inc_ref("tmp", rtype)
+        emitter.emit_line(f"CPyTagged_SetAttr((PyObject *)self, &self->{attr_field}, tmp);")
+        if deletable:
+            emitter.emit_line("} else {")
+            emitter.emit_line(
+                f"CPyTagged_SetAttr((PyObject *)self, &self->{attr_field}, CPY_INT_TAG);"
+            )
+            emitter.emit_line("}")
+        emitter.emit_line("return 0;")
+        emitter.emit_line("}")
+        return
+
     # HACK: Don't consider refcounted values as always defined, since it's possible to
     #       access uninitialized values via 'gc.get_objects()'. Accessing non-refcounted
     #       values is benign.
 
@@ -462,9 +462,22 @@ def emit_load_attr_take_ref(
         safe by borrow_generator_attrs. The default (GIL) build always takes the plain-load
         path and increfs separately.
 
+        Non-Final 'int' attributes use CPyTagged_GetAttr on free-threaded builds, which
+        also returns a new reference (or CPY_INT_TAG if undefined). Final 'int'
+        attributes keep the plain load + incref, like CPy_GetAttrRefFinal.
+
         Thread-confined attributes also use plain loads; see
         ClassIR.attrs_are_thread_confined.
         """
+        if (
+            IS_FREE_THREADED
+            and is_int_rprimitive(attr_rtype)
+            and not op.is_borrowed
+            and not cl.attrs_are_thread_confined()
+            and not cl.is_final_attr(op.attr)
+        ):
+            self.emitter.emit_line(f"{dest} = CPyTagged_GetAttr((PyObject *){obj}, &{attr_expr});")
+            return True
         use_get_attr_ref = (
             self.emitter.target_python.free_threaded
             and is_simple_refcounted_pointer(attr_rtype)
@@ -570,11 +583,12 @@ def get_attr_with_allow_error_value(self, op: GetAttr) -> None:
 
         attr_expr = self.get_attr_expr(obj, op, decl_cl)
         # On free-threaded builds this takes a new reference atomically (see
-        # emit_load_attr_take_ref). CPy_GetAttrRef returns NULL when the field is
-        # undefined, which is precisely the error value here, so the "NULL without
-        # AttributeError" behavior is preserved (this op has error_kind ERR_NEVER).
-        # is_simple_refcounted_pointer excludes tuples/vecs, so error_value_check's
-        # special cases only matter on the plain-load path (where no ref was taken).
+        # emit_load_attr_take_ref). CPy_GetAttrRef returns NULL and CPyTagged_GetAttr
+        # returns CPY_INT_TAG when the field is undefined, which is precisely the error
+        # value here, so the "error value without AttributeError" behavior is preserved
+        # (this op has error_kind ERR_NEVER). The take-ref paths exclude tuples/vecs, so
+        # error_value_check's special cases only matter on the plain-load path (where no
+        # ref was taken).
         if not self.emit_load_attr_take_ref(dest, obj, op, cl, attr_rtype, attr_expr):
             # Only emit inc_ref if not NULL
             if attr_rtype.is_refcounted and not op.is_borrowed:
@@ -644,6 +658,21 @@ def visit_set_attr(self, op: SetAttr) -> None:
                 )
             if op.error_kind == ERR_FALSE:
                 self.emitter.emit_line(f"{dest} = 1;")
+        elif (
+            IS_FREE_THREADED
+            and is_int_rprimitive(attr_rtype)
+            and not cl.attrs_are_thread_confined()
+        ):
+            # These also steal src, and reclaim the old value if it's a long.
+            attr_expr = self.get_attr_expr(obj, op, decl_cl)
+            if op.is_init:
+                self.emitter.emit_line(f"CPyTagged_InitAttr(&{attr_expr}, {src});")
+            else:
+                self.emitter.emit_line(
+                    f"CPyTagged_SetAttr((PyObject *){obj}, &{attr_expr}, {src});"
+                )
+            if op.error_kind == ERR_FALSE:
+                self.emitter.emit_line(f"{dest} = 1;")
         else:
             # ...and struct access for normal attributes.
             attr_expr = self.get_attr_expr(obj, op, decl_cl)
 
@@ -32,6 +32,53 @@ PyObject *CPy_GetAttrRefSlow(PyObject *v, PyObject *owner, PyObject **field) {
     Py_END_CRITICAL_SECTION();
     return result;
 }
+
+// Cold slow path of CPyTagged_GetAttr, also used for undefined (CPY_INT_TAG) values.
+// Reload the field with acquire (rather than using an acquire fence after the relaxed
+// load, which TSan doesn't model), so that a long stored with release by
+// CPyTagged_SetAttrSlow is fully visible. Then secure a reference to the PyLong using
+// the CPy_GetAttrRef protocol.
+CPy_NOINLINE
+CPy_COLD
+CPyTagged CPyTagged_GetAttrSlow(PyObject *owner, CPyTagged *field) {
+    CPyTagged v = _Py_atomic_load_uintptr_acquire((uintptr_t *)field);
+    if (CPyTagged_IsPointerFree(v)) {
+        return v;
+    }
+    PyObject *p = (PyObject *)(v & ~CPY_INT_TAG);
+    if (_Py_TryIncrefFast(p)) {
+        return v;
+    }
+    if (_Py_TryIncRefShared(p)) {
+        if (v == _Py_atomic_load_uintptr((uintptr_t *)field)) {
+            return v;
+        }
+        Py_DECREF(p);
+    }
+    Py_BEGIN_CRITICAL_SECTION(owner);
+    v = _Py_atomic_load_uintptr_relaxed((uintptr_t *)field);
+    if (!CPyTagged_IsPointerFree(v)) {
+        _Py_NewRefWithLock((PyObject *)(v & ~CPY_INT_TAG));
+    }
+    Py_END_CRITICAL_SECTION();
+    return v;
+}
+
+// Cold slow path of CPyTagged_SetAttr, used when the new or the old value may be a
+// long. Like CPy_SetAttrRef: store the new value under the owner's critical section
+// and release the old value (if it's a long) after leaving it.
+CPy_NOINLINE
+CPy_COLD
+void CPyTagged_SetAttrSlow(PyObject *owner, CPyTagged *field, CPyTagged value) {
+    CPyTagged old;
+    Py_BEGIN_CRITICAL_SECTION(owner);
+    old = _Py_atomic_load_uintptr_relaxed((uintptr_t *)field);
+    _Py_atomic_store_uintptr_release((uintptr_t *)field, value);
+    Py_END_CRITICAL_SECTION();
+    if (!CPyTagged_IsPointerFree(old)) {
+        Py_DECREF((PyObject *)(old & ~CPY_INT_TAG));
+    }
+}
 #endif
 
 /////////////////////////////////////////
 
@@ -162,6 +162,69 @@ static inline void CPy_InitAttrRef(PyObject **field, PyObject *value) {
     _Py_atomic_store_ptr_relaxed(field, value);
 }
 
+// Native attributes of type 'int' (CPyTagged fields).
+//
+// A tagged value is pointer-free if it carries no reference: a short int (tag bit
+// clear) or the undefined value CPY_INT_TAG (a tagged NULL). Only a long int
+// (tag bit set, not CPY_INT_TAG) owns a reference to a PyLong object.
+//
+// Reads and writes of pointer-free values (the common case) use only relaxed loads
+// and stores, with no lock and no refcount operation. A long value goes through
+// cold slow paths that follow the CPy_GetAttrRef/CPy_SetAttrRef protocol on the
+// untagged pointer. The fast path writer never releases a reference, and only
+// stores pointer-free values. Acting on a stale pointer-free view it may overwrite
+// a long concurrently stored by another writer, which then leaks (stays alive
+// forever) -- this needs unsynchronized concurrent writers to the same attribute.
+// Only slow path writers release references, each releasing only the value it
+// loaded under the owner's lock after storing its replacement under that lock, so
+// there are no double frees, and the reader guarantees of CPy_GetAttrRef still
+// hold. Longs are stored with release and dereferenced only after an acquire load.
+//
+// The relaxed fast path gives the same (lack of) ordering guarantees as other
+// unboxed attribute types such as 'bool', 'float' and 'i64'.
+static inline int CPyTagged_IsPointerFree(CPyTagged x) {
+    // Short-int test first: the 'x == CPY_INT_TAG' compare only runs for odd values.
+    return !(x & CPY_INT_TAG) || x == CPY_INT_TAG;
+}
+
+CPy_COLD CPyTagged CPyTagged_GetAttrSlow(PyObject *owner, CPyTagged *field);
+CPy_COLD void CPyTagged_SetAttrSlow(PyObject *owner, CPyTagged *field, CPyTagged value);
+
+// Read an 'int' attribute, returning a new reference (or CPY_INT_TAG if undefined).
+// The hot path costs the same as the GIL build's load + CPyTagged_INCREF. Reading an
+// undefined attribute is an error, so it's left to the slow path, which keeps the
+// hot path to a single tag bit test.
+static inline CPyTagged CPyTagged_GetAttr(PyObject *owner, CPyTagged *field) {
+    CPyTagged v = _Py_atomic_load_uintptr_relaxed((uintptr_t *)field);
+    if (likely(!(v & CPY_INT_TAG))) {
+        return v;
+    }
+    return CPyTagged_GetAttrSlow(owner, field);
+}
+
+// Set an 'int' attribute, stealing the reference to 'value' (CPY_INT_TAG deletes the
+// attribute) and reclaiming the previous value. A long 'value' always takes the
+// locked slow path, even if the old value looks pointer-free: without the lock, a
+// writer can't know that the old value it read isn't a pointer, and releases must
+// happen under the lock (see above).
+static inline void CPyTagged_SetAttr(PyObject *owner, CPyTagged *field, CPyTagged value) {
+    if (likely(CPyTagged_IsPointerFree(value))) {
+        CPyTagged old = _Py_atomic_load_uintptr_relaxed((uintptr_t *)field);
+        if (likely(CPyTagged_IsPointerFree(old))) {
+            _Py_atomic_store_uintptr_relaxed((uintptr_t *)field, value);
+            return;
+        }
+    }
+    CPyTagged_SetAttrSlow(owner, field, value);
+}
+
+// Initialize a previously undefined 'int' attribute, stealing the reference to
+// 'value'. This happens while 'self' is still thread-local, so a relaxed store
+// suffices (see CPy_InitAttrRef).
+static inline void CPyTagged_InitAttr(CPyTagged *field, CPyTagged value) {
+    _Py_atomic_store_uintptr_relaxed((uintptr_t *)field, value);
+}
+
 #endif
 
 // Generated generator and coroutine helpers claim this flag while executing,
 
@@ -9421,3 +9421,96 @@ def test_interpreted_subclass_shadowing() -> None:
     assert (o.read_literal(), o.LITERAL) == (5, 97)
     assert o.read_items() is C.ITEMS
     assert o.ITEMS == [1]
+
+[case testIntAttributeShortAndLongValues]
+from typing import Any, Final
+import sys
+from mypy_extensions import trait
+from testutil import assertRaises
+
+BIG: Final = 2**80
+MEDIUM: Final = 2**40  # Long on 32-bit platforms, short on 64-bit platforms
+
+def make_big(i: int) -> int:
+    # Not a literal, since literals may be immortal
+    return BIG * (i + 1)
+
+class C:
+    __deletable__ = ["n"]
+
+    def __init__(self, n: int) -> None:
+        self.n = n
+
+class Fin:
+    def __init__(self, n: int) -> None:
+        self.n: Final = n
+
+@trait
+class T:
+    k: int
+
+class WithTrait(T):
+    def __init__(self, k: int) -> None:
+        self.k = k
+
+def get_k(t: T) -> int:
+    return t.k
+
+def set_k(t: T, k: int) -> None:
+    t.k = k
+
+def test_transitions() -> None:
+    c = C(1)
+    d: Any = c
+    for v in [BIG, 5, BIG + 1, BIG + 2, -BIG, 0, MEDIUM, -MEDIUM, -1, BIG * 3]:
+        c.n = v
+        assert c.n == v
+        assert d.n == v
+        d.n = v + 1
+        assert c.n == v + 1
+        assert d.n == v + 1
+
+def test_old_long_value_released() -> None:
+    c = C(make_big(1))
+    dynamic_sys: Any = sys
+    # Any, so that boxing doesn't steal the reference on the last use
+    old: Any = c.n
+    before = dynamic_sys.getrefcount(old)
+    c.n = 1
+    assert dynamic_sys.getrefcount(old) == before - 1
+    c.n = make_big(2)
+    old = c.n
+    before = dynamic_sys.getrefcount(old)
+    del c.n
+    assert dynamic_sys.getrefcount(old) == before - 1
+
+def test_delete() -> None:
+    c = C(BIG + 1)
+    del c.n
+    with assertRaises(AttributeError):
+        c.n
+    d: Any = c
+    with assertRaises(AttributeError):
+        d.n
+    d.n = BIG + 2
+    assert c.n == BIG + 2
+    del c.n
+    c.n = BIG + 3
+    assert c.n == BIG + 3
+
+def test_final() -> None:
+    for v in [1, BIG + 1]:
+        f = Fin(v)
+        assert f.n == v
+        d: Any = f
+        assert d.n == v
+
+def test_trait() -> None:
+    # Access through the trait type uses a field offset looked up at runtime
+    w = WithTrait(BIG)
+    assert get_k(w) == BIG
+    set_k(w, 2)
+    assert get_k(w) == 2
+    set_k(w, BIG + 1)
+    assert get_k(w) == BIG + 1
+    assert w.k == BIG + 1