I was curious about the performance of a trie so did a few tests to satisfy myself. First two problems with your original code:

 1. You don't check for EOF in your inner for loop meaning your code will run forever unless the file ends exactly with a `\n`. 

        for(c = fgetc(); c != '\n' && c != EOF; c = fgetc(dict)) //iterate through word
Always check return codes when reading data from files. I suspect this may be the issue with your code "crashing" as even with loading 150k words your code only takes 1.5 seconds with the fix.

 2. Another issue is the mixing of `fopen(..., "r")` with `fseek()` depending on if your word file contains `\n` or `\r\n` line terminations. Using mode `r` with `\n` will probably result in incorrect parsing when seeking...at least it did with me using VS2010 on Windows7 causing considerable head scratching. Changing the mode to `rb` fixed the seek issue but eliminating the seek altogether is a better fix and then the file mode doesn't matter.

The other answers go over a variety of good optimizations and code improvements but I wanted to look specifically at how each one impacts the performance of the loading code (Note: please take the times below with a grain of salt...do your own benchmarks if performance really matters):

 1. Your original code (with the two fixes mentioned above) takes **1500ms** to load/parse 150k english words. Not necessarily bad. It results in 388k allocations of new nodes.
 2. Removing the `fseek()` call reduces this to **1060ms**.
 3. Loading the file all at once (only 1.5MB) and parsing the string using `strtok()` has a very small performance increase to **1000 ms**.
 4. Replacing the `strtok()` with manual parsing logic has no visible effect.
 5. At this point the only obvious thing left is to optimize the individual allocations with one block allocation (see code at the end). This has a huge effect on performance reducing the loading time to only **15 ms**. Hopefully that is fast enough for you....
 6. At this point there isn't anything obvious left to optimize. You could try saving and loading the completely parsed trie but the I'm not sure if you'd gain much with the larger read size involved. Profiling would be your best bet to see what, if anything, could be optimized.

Note that the code below is missing some error handling/checking code for simplicity and the node allocation size is hard coded for the same reason. Look up "block/bucket/arena allocators" for more details on this type of optimization.

             // Loads 150k word dictionary in 15ms (x100 faster than original implementation)
    bool loadfaster(const char* dictionary)
    {
    		// Size is hard coded for this example code (388k allocations used)
            // You'd also want to be able to free() the memory some how
    	node* pNodeBucket = calloc(400000, sizeof(node));
    	node* pNextFreeNode = pNodeBucket;
    
    	FILE* dict = fopen(dictionary, "rb");  // "b" mode is important here
        if(dict == false) return false;
    
    		// Get size of file: should check for error codes here
    	fseek(dict, 0, SEEK_END);
    	long Size = ftell(dict);
    	fseek(dict, 0, SEEK_SET);
    
            // Read entire file: should check for read error here
    	char* pBuffer = malloc(Size + 1);
    	fread(pBuffer, 1, Size, dict);
    	fclose(dict);
    
    		// File data will not be nul terminated when read
    	pBuffer[Size] = '\0';
    
        root = pNextFreeNode++;
        node* current = NULL;
    	
        int c = 0;
    	char* pParse = pBuffer;
    
    	while (*pParse)
    	{
    		current = root;
    
           for(; *pParse != '\n' && *pParse; ++pParse)
           {
                if(current->children[*pParse-'a'] == NULL)
                {
                    current->children[*pParse-'a'] = pNextFreeNode++;
                }
                
    			current = current->children[*pParse-'a'];
            }
    
            current->is_word = true;
            nwords++;
    
    		if (*pParse == '\n') ++pParse;
    	}
    	    
    	free(pBuffer);
        return true;    
    }