how to realloc an empty 2d array

Here, you should be using malloc() instead of realloc() since you are not re-allocating memory here.

But if your code can't know if the data is new, it should first be initialized to NULL in order for realloc() to work.

I would change the function to use malloc the first time and realloc after that.

However, there is no need to realloc for the current elements of x. You only need to use malloc for the new elements of x.

void myfunc(int n)
{
   static int n0 = 0;
   static double **x = NULL;

   if ( n > n0)
   {
      if ( x == NULL )
      {
         // Use malloc to get memory for x
         x = malloc(n*sizeof(double*));

         for( int i = 0; i < n; i++)
         {
            x[i] = malloc(2*sizeof(double));
         }
      }
      else
      {
         // Use realloc to get more memory for x.
         x = realloc(x, n*sizeof(double*));

         // Allocate memory only for the new elements of x.
         for( int i = n0; i < n; i++)
         {
            x[i] = malloc(2*sizeof(double));
         }
      }

      n0 = n;
   }
}

PS Don't cast the return value of malloc or realloc. See Specifically, what's dangerous about casting the result of malloc? to understand why.

After a little bit of thought, I realized the function can be simplified a bit.

void myfunc(int n)
{
   static int n0 = 0;
   static double **x = NULL;

   if ( n > n0)
   {
      if ( x == NULL )
      {
         // Use malloc
         x = malloc(n*sizeof(double*));
      }
      else
      {
         // Use realloc
         x = realloc(x, n*sizeof(double*));
      }

      // Use malloc for the new elements of x.
      // When n0 is 0, it will be all of them.
      for( int i = n0; i < n; i++)
      {
         x[i] = malloc(2*sizeof(double));
      }

      n0 = n;
   }
}

void myfunc(int n){

  static int n0=0,i;
  static double **x=NULL;

  if(n>n0){
    x=realloc(x,n*sizeof(double*)));
    for(i=n0;i<n;i++){
      x[i]=malloc(2*sizeof(double)));
    }
    n0=n;
  }

}

In addition to various answer detailing how to increase the allocation, code could be altered to allow an eventual freeing of the allocation by calling with myfunc(0).

Also better to use size_t for array sizing.

No need for i to be static.

This function hides its result, perhaps return the pointer?

double **myfunc(size_t n) {
  static size_t n0 = 0;
  static double **x = NULL;

  if (n > n0) {
    void *new_ptr = realloc(x, sizeof *x * n);
    if (new_ptr == NULL) {
      TBD_Code();  // Handle out-of-memory
    }
    x = new_ptr;
    for (size_t i = n0; i < n; i++) {
      x[i] = malloc(sizeof *(x[i]) * 2);
    }
    n0 = n;
  } else if (n == 0) {
    while (n0 > 0) [
      free(x[--n0]);
    }
    free(x);
    x = NULL;
  }
  return x;
}

Consider ptr = malloc(sizeof *ptr * n); style of using *alloc(). It is easier to code right, review and maintain than ptr = malloc(sizeof (de-referenced_ptr_type) * n);