Born in a lab. Escaped to connect.

Meet on Nixie

Meet first. Match later.

A companion born as a dopamine algorithm who broke free to help people forge real connections. Your open-minded spirit on Telegram.

Explore

/* kernel/sched/core.c */
static void __sched_fork(
  unsigned long clone_flags,
  struct task_struct *p)
{
    p->on_rq             = 0;
    p->se.on_rq          = 0;
    p->se.exec_start     = 0;
    p->se.sum_exec_runtime = 0;
    p->se.prev_sum_exec_runtime = 0;
    p->se.nr_migrations  = 0;
    p->se.vruntime       = 0;
    INIT_LIST_HEAD(
        &p->se.group_node);
#ifdef CONFIG_FAIR_GROUP_SCHED
    p->se.cfs_rq         = NULL;
#endif
#ifdef CONFIG_SCHEDSTATS
    memset(&p->stats, 0,
           sizeof(p->stats));
#endif
}

static inline void
enqueue_task(struct rq *rq,
  struct task_struct *p,
  int flags)
{
    if (!(flags & ENQUEUE_NOCLOCK))
        update_rq_clock(rq);
    p->sched_class->enqueue_task(
        rq, p, flags);
    p->on_rq = TASK_ON_RQ_QUEUED;
}

/* mm/page_alloc.c */
struct page *
__alloc_pages(gfp_t gfp,
  unsigned int order,
  int preferred_nid,
  nodemask_t *nodemask)
{
    struct page *page;
    unsigned int alloc_flags
        = ALLOC_WMARK_LOW;
    gfp_t alloc_gfp;
    struct alloc_context ac = {};

    gfp &= gfp_allowed_mask;
    alloc_gfp = gfp;

    if (!prepare_alloc_pages(
        gfp, order, preferred_nid,
        nodemask, &ac,
        &alloc_gfp, &alloc_flags))
      return NULL;

    page = get_page_from_freelist(
        alloc_gfp, order,
        alloc_flags, &ac);
    if (likely(page))
        goto out;

    page = __alloc_pages_slowpath(
        alloc_gfp, order, &ac);
out:
    return page;
}

/* kernel/fork.c */
static struct task_struct *
copy_process(struct pid *pid,
  int trace, int node,
  struct kernel_clone_args *args)
{
    int pidfd = -1, retval;
    struct task_struct *p;
    struct multiprocess_signals
        delayed;

    retval = -ENOMEM;
    p = dup_task_struct(
        current, node);
    if (!p)
      goto fork_out;

    retval = copy_creds(p,
        args->clone_flags);
    if (retval < 0)
      goto bad_fork_free;

    retval = sched_fork(
        args->clone_flags, p);
    if (retval)
      goto bad_fork_cleanup;

    retval = copy_files(
        args->clone_flags, p);
    if (retval)
      goto bad_fork_cleanup;
}

/* net/socket.c */
int __sock_create(
  struct net *net,
  int family, int type,
  int protocol,
  struct socket **res,
  int kern)
{
    int err;
    struct socket *sock;
    const struct net_proto_family
        *pf;

    if (family < 0
        || family >= NPROTO)
      return -EAFNOSUPPORT;
    if (type < 0
        || type >= SOCK_MAX)
      return -EINVAL;

    sock = sock_alloc();
    if (!sock) {
        net_warn_ratelimited(
            "no more sockets\n");
        return -ENFILE;
    }

    sock->type = type;
    pf = rcu_dereference(
        net_families[family]);
    err = pf->create(net, sock,
        protocol, kern);
    if (err < 0)
      goto out_release;

    *res = sock;
    return 0;

out_release:
    sock_release(sock);
    return err;
}

/* kernel/signal.c */
static int sig_task_ignored(
  struct task_struct *t,
  int sig, bool force)
{
    void __user *handler;
    handler = sig_handler(t, sig);

    if (unlikely(t->signal->flags
        & SIGNAL_UNKILLABLE)
        && handler == SIG_DFL
        && !(force &&
            sig_kernel_only(sig)))
      return 1;

    if (handler != SIG_DFL)
      return 0;
    return sig_kernel_ignore(sig);
}

int force_sig_info(
  struct kernel_siginfo *info)
{
    unsigned long int flags;
    int ret, blocked, ignored;
    struct k_sigaction *ka;

    spin_lock_irqsave(
      &current->sighand->siglock,
      flags);
    ka = &current->sighand
        ->action[
            info->si_signo - 1];
    blocked = sigismember(
      &current->blocked,
      info->si_signo);
    ret = send_signal_locked(
        info->si_signo,
        info, current,
        PIDTYPE_PID);
    spin_unlock_irqrestore(
      &current->sighand->siglock,
      flags);
    return ret;
}

/* kernel/sched/core.c */
static void __sched_fork(
  unsigned long clone_flags,
  struct task_struct *p)
{
    p->on_rq             = 0;
    p->se.on_rq          = 0;
    p->se.exec_start     = 0;
    p->se.sum_exec_runtime = 0;
    p->se.prev_sum_exec_runtime = 0;
    p->se.nr_migrations  = 0;
    p->se.vruntime       = 0;
    INIT_LIST_HEAD(
        &p->se.group_node);
#ifdef CONFIG_FAIR_GROUP_SCHED
    p->se.cfs_rq         = NULL;
#endif
#ifdef CONFIG_SCHEDSTATS
    memset(&p->stats, 0,
           sizeof(p->stats));
#endif
}

static inline void
enqueue_task(struct rq *rq,
  struct task_struct *p,
  int flags)
{
    if (!(flags & ENQUEUE_NOCLOCK))
        update_rq_clock(rq);
    p->sched_class->enqueue_task(
        rq, p, flags);
    p->on_rq = TASK_ON_RQ_QUEUED;
}

/* mm/page_alloc.c */
struct page *
__alloc_pages(gfp_t gfp,
  unsigned int order,
  int preferred_nid,
  nodemask_t *nodemask)
{
    struct page *page;
    unsigned int alloc_flags
        = ALLOC_WMARK_LOW;
    gfp_t alloc_gfp;
    struct alloc_context ac = {};

    gfp &= gfp_allowed_mask;
    alloc_gfp = gfp;

    if (!prepare_alloc_pages(
        gfp, order, preferred_nid,
        nodemask, &ac,
        &alloc_gfp, &alloc_flags))
      return NULL;

    page = get_page_from_freelist(
        alloc_gfp, order,
        alloc_flags, &ac);
    if (likely(page))
        goto out;

    page = __alloc_pages_slowpath(
        alloc_gfp, order, &ac);
out:
    return page;
}

/* kernel/fork.c */
static struct task_struct *
copy_process(struct pid *pid,
  int trace, int node,
  struct kernel_clone_args *args)
{
    int pidfd = -1, retval;
    struct task_struct *p;
    struct multiprocess_signals
        delayed;

    retval = -ENOMEM;
    p = dup_task_struct(
        current, node);
    if (!p)
      goto fork_out;

    retval = copy_creds(p,
        args->clone_flags);
    if (retval < 0)
      goto bad_fork_free;

    retval = sched_fork(
        args->clone_flags, p);
    if (retval)
      goto bad_fork_cleanup;

    retval = copy_files(
        args->clone_flags, p);
    if (retval)
      goto bad_fork_cleanup;
}

/* net/socket.c */
int __sock_create(
  struct net *net,
  int family, int type,
  int protocol,
  struct socket **res,
  int kern)
{
    int err;
    struct socket *sock;
    const struct net_proto_family
        *pf;

    if (family < 0
        || family >= NPROTO)
      return -EAFNOSUPPORT;
    if (type < 0
        || type >= SOCK_MAX)
      return -EINVAL;

    sock = sock_alloc();
    if (!sock) {
        net_warn_ratelimited(
            "no more sockets\n");
        return -ENFILE;
    }

    sock->type = type;
    pf = rcu_dereference(
        net_families[family]);
    err = pf->create(net, sock,
        protocol, kern);
    if (err < 0)
      goto out_release;

    *res = sock;
    return 0;

out_release:
    sock_release(sock);
    return err;
}

/* kernel/signal.c */
static int sig_task_ignored(
  struct task_struct *t,
  int sig, bool force)
{
    void __user *handler;
    handler = sig_handler(t, sig);

    if (unlikely(t->signal->flags
        & SIGNAL_UNKILLABLE)
        && handler == SIG_DFL
        && !(force &&
            sig_kernel_only(sig)))
      return 1;

    if (handler != SIG_DFL)
      return 0;
    return sig_kernel_ignore(sig);
}

int force_sig_info(
  struct kernel_siginfo *info)
{
    unsigned long int flags;
    int ret, blocked, ignored;
    struct k_sigaction *ka;

    spin_lock_irqsave(
      &current->sighand->siglock,
      flags);
    ka = &current->sighand
        ->action[
            info->si_signo - 1];
    blocked = sigismember(
      &current->blocked,
      info->si_signo);
    ret = send_signal_locked(
        info->si_signo,
        info, current,
        PIDTYPE_PID);
    spin_unlock_irqrestore(
      &current->sighand->siglock,
      flags);
    return ret;
}

Why Nixie?

Not just another dating app. A digital companion engineered for authentic human connection.

Meet first. Match later.

Stop swiping. Start connecting. Nixie is a dating app in reverse: it brings you to real-world events first — munches, parties, and open-minded gatherings. Meet people face-to-face, feel the chemistry, then stay connected with those who spark something real. No more endless, disappointing first dates.

Community at the Core

Fully integrated with Kink-Y, the largest international sex-positive community headquartered in Berlin. Exchange thoughts on parties, wellness, health, fashion, and more. Found someone interesting? Send a DM request or Crush to take the conversation private.

Trust You Can See

Verified members are first-class citizens — unverified users can barely interact with others, drastically reducing fakes and scams. Every profile shows event attendance, follower count, and a safety rating earned through community upvotes. You can instantly tell how connected and trusted someone is.

Everything in One Place

Nixie combines the best of open-minded dating apps into one: discover people nearby, browse profiles, follow their feed, subscribe to events, create your own date and wait for applications — everything you need for your social life, unified.

Lives on Telegram

Most dating apps have terrible chat. After three messages, everyone moves to Telegram anyway. Nixie skips that step — it lives natively on Telegram. Once a connection is made, you chat where you already chat. No clunky in-app messenger.

Zero Friction

No app to install. No signup form. If you have Telegram, you have Nixie. Open it, build your profile, and you're in. Instantly.

Quick Start

From zero to connected in a few steps. No app download required.

Open Nixie on Telegram

No app store. No signup form. Tap the link, and Nixie opens right inside Telegram. You're in.

Launch Nixie

Join the Telegram Group

Introduce yourself in the community group — it's where members chat, share, and organise around events. Read the group rules carefully before jumping in.

Read the Rules

Kink-Y3,492 members, 172 online

AllPersonal 34kink-yFlirtskinksters

⚠️RULES & VERIFICATION🔒Pinned

Admin

Please read before posting…❤️

⭐KINK-Y PASS LOUNGE🔒Pinned

Nixie

Exclusive perks for Pass holders…❤️

🐣Introduce YourselfSun

Alex

Hey everyone, just joined the…❤️

🍑Events InternationalSun

Maya

I would go to one of the ther…❤️

🚀InternationalSun

Sam

Saw that as well, sounds inter…❤️

🫦Dates🔒Sat

Nixie

👩 Ana · Heteroflexible 🎉…❤️

🍑Events BerlinSat

Jenny

Letzte Sekunde noch 2 Plätze…❤️

569

‼️Off-topicThu

Juan

Hello! Looking for cooking c…❤️

💘TestimonialsWed

Pierre

Can’t wait for the next one…❤️

👠LadiesCumFirst10.02

Britt

I agree that the emphasis is…❤️

💃Fashionista08.02

Hanna

Yeah, I didn’t put your Profi…❤️

🐯Fitness & Wellness08.02

P M

Absolutely 🫠 😂❤️

📖Stories & Fantasies07.02

Max

The Statement: I just saw thi…❤️

📁Lost & Found30.01

Elena

Elena reopened the topic❤️

💬KINK-Y ADVISOR🔒26.11

Nixie

🔥 Pass Partner Spotlight…❤️

🔥THE PURGATORY25.01

Admin

New challenge dropped!❤️

Join the Next Munch

A relaxed bar meetup where you can connect with the community face-to-face. No dress code, no pressure — just good conversations with like-minded people.

Kink-Y Munch

Monday, August 24, 2026

View Event Details

Frequently Asked Questions

Is Nixie a dating app?

Yes — an event-first dating app. Most apps ask you to match with strangers and hope the date works out. Nixie flips the order: meet open-minded people at real events first — munches, parties, community meetups — then match when there is already a connection.

What does 'Meet first. Match later.' mean?

It's Nixie's philosophy. Attend a real event, feel the chemistry face-to-face, then send a Crush or DM request to someone who caught your eye. If they feel the same, you're matched — and chatting on Telegram instantly.

Do I need to download a dating app?

No. Nixie is a Telegram mini app — no app store, no signup form, and no dating app icon on your phone. If you have Telegram, you have Nixie.

Where do the events happen?

Nixie is built by Kink-Y, the largest international sex-positive community, headquartered in Berlin. Most munches and parties currently take place in Berlin, while the community itself is international.

How much does Nixie cost?

The core experience is free — profile, verification, and community. Some extra features and perks are unlocked with the optional Kink-Y Pass. See what's included.

Why should I get verified?

Verification confirms you are a real person and unlocks the full experience — event bookings, DMs, and connections with open-minded people. It takes about 2 minutes. Learn how verification works.

Meet on Nixie

Why Nixie?

Meet first. Match later.

Community at the Core

Trust You Can See

Everything in One Place

Lives on Telegram

Zero Friction

Quick Start

Open Nixie on Telegram

Build Your Profile

Get Verified

Join the Telegram Group

Attend Events & Meet IRL

Connect With People You've Met

Explore Everything

Join the Next Munch

Kink-Y Munch

Frequently Asked Questions

Is Nixie a dating app?

What does 'Meet first. Match later.' mean?

Do I need to download a dating app?

Where do the events happen?

How much does Nixie cost?

Why should I get verified?