UTAH OUTDOOR ADVENTURE TRAVEL and UTAH VACATIONS by UTAH OUTVENTURES! TRAVEL UTAH! - Click to contact us
UOV layout top
Left Nav Img
Nav Top Img

 

 

 

 

 

 

 

 

 

 

 

 

 

Todays Date:
 
Travel News, Discounted Tours, Specials - Sign Up for Our:
 
Add This Page To Your Favorites
 
Valid HTML 4.01 Transitional

 

 

We Operate Year Round - Contact Us Today!

Nav Right Img
Nav Body Top

Utah Outventures OUTDOOR GEAR SHOP - We have teamed up with the foremost outfitters to bring you the highest quality gear at competitive prices. Utah Outventures staff utilizes the gear we sell. bringing it to test every day out in the field, we know you will find what you are looking for, knowing that you bought the right gear from the right place.

SkI: To some a sport, to others a lifestyle. The most cutting edge tools you need to ski up, down, or across the mountain are all here.

CLOTHING: Nothing can ruin a day in the backcountry faster than not having the right clothing. After countless hours of gear testing, we've selected the best in technical wear & casual clothing from industry leaders.

CAMP / HIKE: Sunrise over a high alpine lake. A trek in the mountains. Pitching a tent far from the city...the backcountry beckons. After years of fieldwork, we've compiled the most technical, high-quality camping, backpacking & hiking gear by Kelty, Lowa, MSR, The North Face and more.

TRAVEL: Not everyone who wanders is lost. Explore, experience, engage. Herein lie the tools to keep you packed & organized, safely hydrated, and on the trail…when you want to be. Choose from Eagle Creek, Jansport, The North Face, Katadyn and more.

 
Men's Clothing
Women's Clothing
Camp/Hike
Bike
Climb
Travel
Kids'
Trail Run
Ski
Snowboard
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