Using concat in C without string library functions or array notation

Besides the unitialized int i = 0, your code seems fine. This worked on my machine:

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

char* concat(char* first, char* second){
    int string1Len = strlen(first);
    int string2Len = strlen(second);
    int length = string1Len + string2Len;
    char* string = malloc(sizeof(char)*length + 1);
    assert(string);
    int i=0;
    while(i < string1Len){
        string[i] = *first;
        first+= 1;
        i+= 1;
    }
    while(i < length){
        string[i] = *second;
        second += 1;
        i += 1;
    }
    string[i] = '\0';
    return string;
}

int main(){
        char* x = "foo";
        char* y = "bar";
        printf("%s\n", concat(x, y));
        // prints 'foobar'
}

P.S. use string[i] instead of *(string + i), it's generally considered more readable.

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

// You should use char const * as your function don't need to change the character of your input string
char *concat(char const *first, char const *second) { // put * on the variable name not the type
    assert(first && second); // test only include for debug build concat expect valid string
    size_t first_len = strlen(first); // strlen() return a size_t
    size_t second_len = strlen(second);
    // you could check for overflow case here
    size_t length = first_len + second_len; // malloc take a size_t as argument
    char *string = malloc(length + 1); // don't forget the nul terminate byte, sizeof(char) == 1
    if (!string) { // don't forget to check malloc() error
        return NULL;
    }
    size_t i = 0; // don't forget to initialize your variable
    while (*first) {
        string[i++] = *first++; // use [] notation is more readeable  in that case
    }
    while (*second) {
        string[i++] = *second++;
    }
    string[i] = '\0'; // never forget the nul terminate byte
    return string;
}

int main(void) {
    char *my_amazing_new_string = concat("Stack ", "Overflow");
    if (!my_amazing_new_string) {
        return EXIT_FAILURE;
    }
    printf("%s", my_amazing_new_string);
    free(my_amazing_new_string);
}

OP's code errors

Index not initialized

// int i;
int i = 0;

No null character appended nor allocated

// char* string = malloc(sizeof(char)*length);
char* string = malloc(length + 1);
....
*(string + i) ='\0'; // add this
return string;

Minor stuff

sizeof(char) is always 1

//char* string = malloc(sizeof(char)*length);
char* string = malloc(length);  // Also +1 as noted above

int may be too narrow

// int i;
size_t i;

Can't use strlen()

"without string library functions"

Allocation lacks check

char* string = malloc(...);
if (string == NULL) {  // add
  return NULL;
}

As source strings are not modified, use const.

This allows greater use of the function and potential optimizations.

//char* concat(char* first, char* second){
char* concat(const char* first, const char* second){

Some untested alternative code. Note no integer variables.

char* concat(const char* first, const char* second) {
  const char *p1 = first;
  while (*p1) {
    p1++;
  }
  const char *p2 = second;
  while (*p2) {
    p2++;
  }
  char* string = malloc((p1 - first) + (p2 - second) + 1);
  if (string) {
    char *ps = string;
    while ((*ps = *first++)) {
      ps++;
    }
    while ((*ps = *second++)) {
      ps++;
    }
  }
  return string;
}

String Libraries? I never use them :P

char * concat(char * dest, const char * src)
{
    // creates a pointer to `dest` so we can return it from from its start position.
    char * ptr = dest;          
    // increment dest until the null-terminated which is 0 (false//loop stops).
    while (*dest) dest++;   
    // so we assign dest pointer to src pointer while incrementing them.    
    while (*dest++ = *src++);   
    // return the `dest` pointer.
    return ptr;                 
}

Note that you'll need to allocate the first parameter yourself cause this function does concat the dest pointer itself, So the return value (is Optional ^^).

I also noticed that for some reason... everyone's allocating memory in the function itself, so I did my 2nd version. However, it's not like 1st one (You'll need the return value though).

char * concat(char * s1, const char * s2)
{
    size_t i = 0;
    // length of s1.
    while (*s1++) i++;
    size_t s1_len = i; i = 0;
    s1 -= s1_len + 1;
    // length of s2.
    while (*s2++) i++;
    size_t s2_len = i; i = 0;
    s2 -= s2_len + 1;
    // allocates memory.
    char * newStr = (char *)malloc((s1_len + s2_len)+1); // +1 is for the nul-terminated character.
    if(!newStr) return newStr; // if malloc fails, return (null) pointer.
    // points to position 0 of the 1st string.
    char * ptr = newStr;
    // copies the content of s1 to the new string
    while (*ptr++ = *s1++);
    // get back to the null-terminated to overwrite it.
    *ptr--;
    // concentrate
    while (*ptr++ = *s2++);
    // return the `newStr` pointer.
    return newStr;                  
}